multiptr.h

/* -*- c++ -*- */
/*
 * Expresso, a C++ Array template class library
 * Copyright (C) 1998,2004 Oskar Enoksson (enok@lysator.liu.se)
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 */
#ifndef EXPRESSO_MULTIPTR_HDR
#define EXPRESSO_MULTIPTR_HDR

namespace esso {

  template<class T>
  struct MultiPtr_Block {
    inline T *Data() { return data; }
      
    inline void Attach() { ++counter; }
    inline void Detach() { if(--counter==0) delete this; }
      
    inline MultiPtr_Block(unsigned size0): counter(0), data(0) {
      data=new T[size0];
    }
    inline ~MultiPtr_Block() { delete [] data; }
  protected:
    unsigned counter;
    T *data;
  };

// MultiPtr class template definition
  template<class T>
  class MultiPtr {
// Class that keeps track of dynamically allocated memory used by
// one or more other objects. The idea is that the data in a
// MultiPtr::Block is destroyed when (and only when) the last MultiPtr
// pointing to it is destroyed. This is done by reference counting
  private:
  public:
    friend class MultiPtr<const T>;
    inline T * Data() const { return block ? block->Data() : 0; }
    inline void clear() {
      if(block) {
        block->Detach();
        block = 0;
      }
    }
    inline MultiPtr & operator =(const MultiPtr &src) {
      MultiPtr_Block<T> *tmp=block; // Self-assignment is safe!
      block=src.block;
      if(block)
        block->Attach();
      if(tmp)
        tmp->Detach();
      return *this;
    }
    inline MultiPtr(): block(0) {}
    inline MultiPtr(unsigned size0): block(0) { 
      if(size0) {
        block = new MultiPtr_Block<T>(size0);
        block->Attach(); 
      }
    }
    inline MultiPtr(const MultiPtr &src): block(src.block) { 
      if(block) block->Attach();
    }
    inline ~MultiPtr() { if(block) block->Detach(); }
  private:
    MultiPtr_Block<T> *block;
  };

  template<class T>
  class MultiPtr<const T> {
  public:
    inline const T * Data() const { return block ? block->Data(): 0; }
    inline void clear() {
      if(block) {
        block->Detach();
        block = 0;
      }
    }
    inline MultiPtr & operator =(const MultiPtr &src) {
      MultiPtr_Block<T> *tmp=block; // Self-assignment is safe!
      block=src.block;
      if(block)
        block->Attach();
      if(tmp)
        tmp->Detach();
      return *this;
    }
    inline MultiPtr & operator =(const MultiPtr<T> &src) {
      MultiPtr_Block<T> *tmp=block; // Self-assignment is safe!
      block=src.block;
      if(block)
        block->Attach();
      if(tmp)
        tmp->Detach();
      return *this;
    }
    inline MultiPtr(): block(0) {}
    inline MultiPtr(unsigned size0): block(0) { 
      if(size0) {
        block = new MultiPtr_Block<T>(size0);
        block->Attach(); 
      }
    }
    inline MultiPtr(const MultiPtr &src): block(src.block) { 
      if(block) block->Attach(); 
    }
    inline MultiPtr(const MultiPtr<T> &src): block(src.block) { 
      if(block) block->Attach(); 
    }
    inline ~MultiPtr() { if(block) block->Detach(); }
  private:
    MultiPtr_Block<T> *block;
  };

}
#endif

---