/*
    * Copyright 2013 The Netty Project
    *
    * The Netty Project licenses this file to you 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.
   */
  
  package io.netty.buffer;
  
  import io.netty.util.IllegalReferenceCountException;
  
  import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
  
  import static io.netty.util.internal.ObjectUtil.checkPositive;
  
  /**
   * Abstract base class for {@link ByteBuf} implementations that count references.
   */
  public abstract class AbstractReferenceCountedByteBuf extends AbstractByteBuf {
  
      private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater =
              AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
  
      private volatile int refCnt;
  
      protected AbstractReferenceCountedByteBuf(int maxCapacity) {
          super(maxCapacity);
          refCntUpdater.set(this, 1);
      }
  
      @Override
      public int refCnt() {
          return refCnt;
      }
  
      /**
       * An unsafe operation intended for use by a subclass that sets the reference count of the buffer directly
       */
      protected final void setRefCnt(int refCnt) {
          refCntUpdater.set(this, refCnt);
      }
  
      @Override
      public ByteBuf retain() {
          return retain0(1);
      }
  
      @Override
      public ByteBuf retain(int increment) {
          return retain0(checkPositive(increment, "increment"));
      }
  
      private ByteBuf retain0(final int increment) {
          int oldRef = refCntUpdater.getAndAdd(this, increment);
          if (oldRef <= 0 || oldRef + increment < oldRef) {
              // Ensure we don't resurrect (which means the refCnt was 0) and also that we encountered an overflow.
              refCntUpdater.getAndAdd(this, -increment);
              throw new IllegalReferenceCountException(oldRef, increment);
          }
          return this;
      }
  
      @Override
      public boolean release() {
          return release0(1);
      }
  
      @Override
      public boolean release(int decrement) {
          return release0(checkPositive(decrement, "decrement"));
      }
  
      private boolean release0(int decrement) {
          int oldRef = refCntUpdater.getAndAdd(this, -decrement);
          if (oldRef == decrement) {
              deallocate();
              return true;
          } else if (oldRef < decrement || oldRef - decrement > oldRef) {
              // Ensure we don't over-release, and avoid underflow.
              refCntUpdater.getAndAdd(this, decrement);
              throw new IllegalReferenceCountException(oldRef, decrement);
          }
          return false;
      }
      /**
       * Called once {@link #refCnt()} is equals 0.
       */
      protected abstract void deallocate();
  }