refcount.h

// -*- mode: c++; fill-column: 80; c-basic-offset: 2; indent-tabs-mode: nil -*-
/*
    Copyright (c) 2010 Juan Jose Garcia Ripoll

    Tensor 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 program 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 General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifndef TENSOR_REFCOUNT_H
#define TENSOR_REFCOUNT_H

#include <cstring>
#include <algorithm>

namespace tensor {

template<class value_type>
class RefPointer {
public:
  typedef value_type elt_t; 

  RefPointer();
  RefPointer(size_t new_size);
  RefPointer(elt_t *data, size_t size, bool owned = true);
  RefPointer(const RefPointer<elt_t> &p);


  ~RefPointer();

  RefPointer<elt_t> &operator=(const RefPointer<elt_t> &p);

  elt_t *begin() { appropriate(); return ref_->begin(); }
  const elt_t *begin() const { return ref_->begin(); }
  const elt_t *begin_const() const { return ref_->begin(); }
  const elt_t *end_const() const { return ref_->end(); }
  const elt_t *end() const { return ref_->end(); }
  elt_t *end() { appropriate(); return ref_->end(); }

  size_t size() const { return ref_->size(); }

  size_t ref_count() const { return ref_->references(); }

  void reallocate(size_t new_size);

private:
  class pointer;
  mutable pointer *ref_; // Pointer to data we reference or NULL

  void appropriate();
  pointer *reference() const;
  void dereference();
};

  template<typename T>
  class shared_ptr {
  public:
    shared_ptr(T *t) : _value(t), _ref(new int(1)) {}
    ~shared_ptr() { --(*_ref); if (!(*_ref)) { delete _value; delete _ref; }}
    T* operator->() const { return _value; }
    T& operator*() const { return *_value; }
  private:
    int *_ref;
    T *_value;
  };

}; // namespace

#include <tensor/detail/refcount.hpp>

#endif /* !REFCOUNT_REFCOUNT_H */