ref.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <archon/util/text.H>
#include <archon/util/ref.H>

namespace Archon
{
  namespace Utilities
  {
    RefMapBase::RefMapBase()
    {
      for(unsigned i=0; i<hashSize; ++i) chunks[i] = 0;

      // Add null as the first entry to correspond with the null
      // index.
      refs.push_back(pair<RefObjectBase *, unsigned long>(0, 0));
    }

    RefMapBase::~RefMapBase()
    {
      for(unsigned i=0; i<hashSize; ++i) if(chunks[i]) delete chunks[i];
      for(unsigned i=1; i<refs.size(); ++i)
      {
        RefObjectBase *r = refs[i].first;
        if(r) r->refDec();
      }
    }

    string RefMapBase::disp()
    {
      Mutex::Lock l(refMapMutex);
      string s;
      unsigned long m = 1;
      for(unsigned i=0; i<hashSize; ++i)
        if(chunks[i] && chunks[i]->size() > m) m = chunks[i]->size();
      char buffer[1024];
      for(unsigned i=0; i<hashSize; ++i)
      {
        unsigned long n = chunks[i] ? chunks[i]->size() : 0;
        string bar = string(unsigned(70UL*n/m), '+');
        sprintf(buffer, "%7lu |%-70s|\n", n, bar.c_str());
        s += string(buffer);
      }
      return s;
    }

    unsigned long RefMapBase::get(RefObjectBase *r, bool create)
    {
      if(!r) return 0;
      unsigned long h = reinterpret_cast<unsigned long>(r) % hashSize;
      vector<unsigned long>::iterator j;
      bool f = false;
      unsigned long index;
      Mutex::Lock l(refMapMutex);
      vector<unsigned long> *c = chunks[h];
      if(c)
      {
        vector<unsigned long>::iterator i = c->begin();
        while(i != c->end())
        {
          index = *i;
          if(index)
          {
            pair<RefObjectBase *, unsigned long> &p = refs[index];
            if(p.first == r)
            {
              ++p.second;
              return index;
            }
          }
          else if(!f)
          {
            f = true;
            j = i;
          }
          ++i;
        }
      }
      if(!create) return 0;

      if(unused.size())
      {
        index = unused.back();
        unused.pop_back();
        pair<RefObjectBase *, unsigned long> &p = refs[index];
        p.first = r;
        p.second = 1;
      }
      else
      {
        index = refs.size();
        refs.push_back(pair<RefObjectBase *, unsigned long>(r, 1));
      }

      r->refInc();

      if(f) *j = index;
      else
      {
        if(!c) c = chunks[h] = new vector<unsigned long>;
        c->push_back(index);
      }

      return index;
    }

    void RefMapBase::removeNoLock(RefObjectBase *r, unsigned long transCount)
    {
      if(!r) return;
      unsigned long h = reinterpret_cast<unsigned long>(r) % hashSize;
      vector<unsigned long> *c = chunks[h];
      if(!c) return;
      vector<unsigned long>::iterator i = c->begin();
      while(i != c->end())
      {
        unsigned long index = *i;
        pair<RefObjectBase *, unsigned long> &p = refs[index];
        if(p.first == r)
        {
          if(transCount)
          {
            if(transCount > p.second) transCount = p.second;
            p.second -= transCount;
            if(p.second) return;
          }
          *i = 0;
          r->refDec();
          p.first = 0;
          p.second = 0;
          unused.push_back(index);
          return;
        }
        ++i;
      }
    }

    void RefMapBase::clearNoLock(bool destroyRefs)
    {
      if(destroyRefs)
        for(unsigned i=1; i<refs.size(); ++i)
        {
          RefObjectBase *r = refs[i].first;
          if(r) r->refDec();
        }
      for(unsigned i=0; i<hashSize; ++i)
      {
        if(!chunks[i]) continue;
        delete chunks[i];
        chunks[i] = 0;
      }
      refs.clear();
      unused.clear();
      refs.push_back(pair<RefObjectBase *, unsigned long>(0, 0));
    }
  }
}

---