categorized_refcount.h

Go to the documentation of this file.

/*
 * Copyright 2013 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_CATEGORIZED_REFCOUNT_H_
#define PAGESPEED_KERNEL_UTIL_CATEGORIZED_REFCOUNT_H_

#include "base/logging.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

template<typename ObjectType, typename EnumType>
class CategorizedRefcount {
 public:
  explicit CategorizedRefcount(ObjectType* object)
      : total_refcount_(0), object_(object), mutex_(NULL) {
    for (int i = 0; i < ObjectType::kNumRefCategories; ++i) {
      ref_counts_[i] = 0;
    }
  }

  void set_mutex(AbstractMutex* mutex) {
    mutex_ = mutex;
  }

  void AddRef(EnumType category) {
    ScopedMutex hold(mutex_);
    AddRefMutexHeld(category);
  }

  void AddRefMutexHeld(EnumType category) {
    mutex_->DCheckLocked();
    DCHECK_LE(0, category);
    DCHECK_LT(category, ObjectType::kNumRefCategories);
    ++ref_counts_[category];
    ++total_refcount_;
  }

  void ReleaseRef(EnumType category) {
    ScopedMutex hold(mutex_);
    ReleaseRefMutexHeld(category);
  }

  void ReleaseRefMutexHeld(EnumType category) {
    mutex_->DCheckLocked();
    DCHECK_LE(0, category);
    DCHECK_LT(category, ObjectType::kNumRefCategories);
    --ref_counts_[category];
    DCHECK_GE(ref_counts_[category], 0) << category;
    --total_refcount_;
    if (total_refcount_ == 0) {
      object_->LastRefRemoved();
    }
  }


  int QueryCountMutexHeld(EnumType category) const {
    return ref_counts_[category];
  }

  GoogleString DebugString() const {
    ScopedMutex hold(mutex_);
    return DebugStringMutexHeld();
  }

  GoogleString DebugStringMutexHeld() const {
    mutex_->DCheckLocked();

    GoogleString out;
    for (int i = 0; i < ObjectType::kNumRefCategories; ++i) {
      StrAppend(&out, "\t", object_->RefCategoryName(static_cast<EnumType>(i)),
                ": ", IntegerToString(ref_counts_[i]));
    }
    return out;
  }

  void DCheckAllCountsZero() {
    ScopedMutex hold(mutex_);
    DCheckAllCountsZeroMutexHeld();
  }

  void DCheckAllCountsZeroMutexHeld() {
    mutex_->DCheckLocked();
    DCHECK_EQ(0, total_refcount_);
    for (int i = 0; i < ObjectType::kNumRefCategories; ++i) {
      DCHECK_EQ(0, ref_counts_[i]);
    }
  }

 private:
  int ref_counts_[ObjectType::kNumRefCategories];
  int total_refcount_;
  ObjectType* object_;
  AbstractMutex* mutex_;
  
};

}  

#endif