content: package androidx.core.util;
  
  public final class Pools {
  
      public interface Pool<T> {
          T acquire();
  
          boolean release(T t);
      }
  
      public static class SimplePool<T> implements Pool<T> {
          private final Object[] mPool;
          private int mPoolSize;
  
          public SimplePool(int maxPoolSize) {
              if (maxPoolSize > 0) {
                  this.mPool = new Object[maxPoolSize];
                  return;
              }
              throw new IllegalArgumentException("The max pool size must be > 0");
          }
  
          private boolean isInPool(T t) {
              for (int i = 0; i < this.mPoolSize; i++) {
                  if (this.mPool[i] == t) {
                      return true;
                  }
              }
              return false;
          }
  
          public T acquire() {
              int i = this.mPoolSize;
              if (i <= 0) {
                  return null;
              }
              int i2 = i - 1;
              T[] tArr = this.mPool;
              T t = tArr[i2];
              tArr[i2] = null;
              this.mPoolSize = i - 1;
              return t;
          }
  
          public boolean release(T t) {
              if (!isInPool(t)) {
                  int i = this.mPoolSize;
                  Object[] objArr = this.mPool;
                  if (i >= objArr.length) {
                      return false;
                  }
                  objArr[i] = t;
                  this.mPoolSize = i + 1;
                  return true;
              }
              throw new IllegalStateException("Already in the pool!");
          }
      }
  
      public static class SynchronizedPool<T> extends SimplePool<T> {
          private final Object mLock = new Object();
  
          public SynchronizedPool(int maxPoolSize) {
              super(maxPoolSize);
          }
  
          public T acquire() {
              T acquire;
              synchronized (this.mLock) {
                  acquire = super.acquire();
              }
              return acquire;
          }
  
          public boolean release(T t) {
              boolean release;
              synchronized (this.mLock) {
                  release = super.release(t);
              }
              return release;
          }
      }
  
      private Pools() {
      }
  }
  