ref_counted_ptr.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_UTIL_REF_COUNTED_PTR_H_
#define PAGESPEED_KERNEL_UTIL_REF_COUNTED_PTR_H_

#include "base/logging.h"
#include "pagespeed/kernel/base/atomic_int32.h"
#include "pagespeed/kernel/base/basictypes.h"

namespace net_instaweb {

template<class T>
class RefCounted {
 public:
  RefCounted() : ref_count_(0) {}
  ~RefCounted() { DCHECK_EQ(0, ref_count_.value()); }

  void Release() {
    if (ref_count_.BarrierIncrement(-1) == 0) {
      delete static_cast<T*>(this);
    }
  }

  void AddRef() {
    ref_count_.NoBarrierIncrement(1);
  }

  bool HasOneRef() {
    return (ref_count_.value() == 1);
  }

 private:
  AtomicInt32 ref_count_;
  
};

template<class T>
class RefCountedPtr {
 public:
  RefCountedPtr() : ptr_(NULL) {}
  explicit RefCountedPtr(T* t) : ptr_(t) {
    if (t != NULL) {
      t->AddRef();
    }
  }

  RefCountedPtr(const RefCountedPtr<T>& src)
      : ptr_(src.ptr_) {
    if (ptr_ != NULL) {
      ptr_->AddRef();
    }
  }

  template<class U>
  explicit RefCountedPtr(const RefCountedPtr<U>& src)
      : ptr_(static_cast<T*>(src.ptr_)) {
    if (ptr_ != NULL) {
      ptr_->AddRef();
    }
  }

  ~RefCountedPtr() {
    if (ptr_ != NULL) {
      ptr_->Release();
    }
  }

  RefCountedPtr<T>& operator=(const RefCountedPtr<T>& other) {
    if (other.ptr_ != NULL) {
      other.ptr_->AddRef();
    }
    if (ptr_ != NULL) {
      ptr_->Release();
    }
    ptr_ = other.ptr_;
    return *this;
  }

  template<class U>
  RefCountedPtr<T>& operator=(const RefCountedPtr<U>& other) {
    if (other.ptr_ != NULL) {
      other.ptr_->AddRef();
    }
    if (ptr_ != NULL) {
      ptr_->Release();
    }
    ptr_ = static_cast<T*>(other.ptr_);
    return *this;
  }

  T* operator->() const { return ptr_; }
  T* get() const { return ptr_; }

  bool unique() const { return !this->ptr_ || this->ptr_->HasOneRef(); }

  template<typename U>
  RefCountedPtr<U> StaticCast() const {
    return RefCountedPtr<U>(static_cast<U*>(this->get()));
  }

  void clear() {
    *this = RefCountedPtr();
  }
  void reset(T* ptr) {
    *this = RefCountedPtr(ptr);
  }
  void reset(const RefCountedPtr& src) {
    *this = src;
  }

 private:
  template <class U> friend class RefCountedPtr;
  operator void*() const; 
  operator T*() const; 

  T* ptr_;
};

template<class T>
class RefCountedObj {
 public:
  RefCountedObj() : data_ptr_(new Data()) {}
  explicit RefCountedObj(const T& val) : data_ptr_(new Data(val)) {}

  bool unique() const { return data_ptr_.unique(); }

  T* get() { return &data_ptr_->value; }
  const T* get() const { return &data_ptr_->value; }
  T* operator->() { return &data_ptr_->value; }
  const T* operator->() const { return &data_ptr_->value; }
  T& operator*() { return data_ptr_->value; }
  const T& operator*() const { return data_ptr_->value; }

  void reset(const T& val) { data_ptr_.reset(new Data(val)); }

 protected:
  struct Data : public RefCounted<Data> {
    Data() {}
    explicit Data(const T& val) : value(val) {}
    T value;
  };

  RefCountedPtr<Data> data_ptr_;

 private:
  operator void*() const; 
  operator T*() const; 

};

#define REFCOUNT_FRIEND_DECLARATION(class_name) \
  friend class net_instaweb::RefCounted<class_name>

}  

#endif