static_memory_gremlin.h

Go to the documentation of this file.

#ifndef STATIC_MEMORY_GREMLIN_CLASS
#define STATIC_MEMORY_GREMLIN_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : static_memory_gremlin                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include <basis/contracts.h>
#include <basis/enhance_cpp.h>
#include <basis/mutex.h>
 
namespace structures {
 
// forward declarations.
class gremlin_object_record;
 
 
class static_memory_gremlin : public virtual basis::nameable
{
public:
  static_memory_gremlin();
 
  ~static_memory_gremlin();
  DEFINE_CLASS_NAME("static_memory_gremlin");
 
  static bool __program_is_dying();
 
  static static_memory_gremlin &__hoople_globals();
 
  static basis::mutex &__memory_gremlin_synchronizer();
 
  void enable_debugging(bool verbose) { c_show_debugging = verbose; }
 
  bool put(const char *unique_name, basis::root_object *ptr);
 
  basis::root_object *get(const char *unique_name);
 
  const char *find(const basis::root_object *ptr);
 
  void ensure_space_exists();
private:
  basis::mutex c_lock;  
  int c_top_index;  
  int c_actual_size;  
  gremlin_object_record **c_pointers;  
  bool c_show_debugging;  
 
  int locate(const char *unique_name);
};
 
 
 
#define SAFE_STATIC(type, func_name, parms) \
  type &func_name() { SAFE_STATIC_IMPLEMENTATION(type, parms, __LINE__); }
 
#define SAFE_STATIC_CONST(type, func_name, parms) \
  const type &func_name() \
  { SAFE_STATIC_IMPLEMENTATION(type, parms, __LINE__); }
 
 
#define STATIC_STRING(str) \
  SAFE_STATIC_IMPLEMENTATION(astring, (str), __LINE__)
 
 
#define UNIQUE_NAME_BASED_ON_SOURCE(name, linenum) \
  static const char *name = "file:" __FILE__ ":line:" #linenum
 
 
#define SAFE_STATIC_IMPLEMENTATION(type, parms, linenum) \
/*hmmm: bring all this back.*/ \
/*  const char *func = "allocation"; */ \
/*  frame_tracking_instance __trail_of_function("safe_static", func, \
      __FILE__, __LINE__, true); */ \
  UNIQUE_NAME_BASED_ON_SOURCE(__uid_name, linenum); \
/*  program_wide_memories(); */ \
  static basis::root_object *_hidden = NULL_POINTER; \
  /* if haven't initialized yet, then definitely need to lock carefully. */ \
  if (structures::static_memory_gremlin::__program_is_dying() || !_hidden) { \
    basis::auto_synchronizer l(structures::static_memory_gremlin::__memory_gremlin_synchronizer()); \
    if (structures::static_memory_gremlin::__program_is_dying()) { \
      /* we can't rely on the pointer since we're shutting down currently. */ \
      _hidden = structures::static_memory_gremlin::__hoople_globals().get(__uid_name); \
    } \
    if (!_hidden) {  /* make sure no one scooped us. */ \
      /* try to retrieve an existing one first and use it if there. */ \
      _hidden = structures::static_memory_gremlin::__hoople_globals().get(__uid_name); \
      if (!_hidden) { \
        _hidden = new type parms ; /* create the object finally. */ \
        /* store our object using the unique name for it. */ \
        if (!structures::static_memory_gremlin::__hoople_globals().put(__uid_name, _hidden)) { \
          /* we failed to allocate space.  this is serious. */ \
          throw __uid_name; \
        } \
      } \
    } \
  } \
  if (!_hidden) { \
    /* grab the pointer that was stored, in case we're late getting here. */ \
    /* another thread might have scooped the object creation. */ \
    _hidden = structures::static_memory_gremlin::__hoople_globals().get(__uid_name); \
  } \
  return *dynamic_cast<type *>(_hidden)
 
// historical note: the SAFE_STATIC approach has existed since about 1998.
// however, the static_memory_gremlin's role in this started much later.
 
} //namespace.
 
#endif