ObjectPoolManager.java

/*
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

package com.facebook.common.objectpool;

import java.util.HashMap;

import com.facebook.common.time.MonotonicClock;

/**
 * Manager for storing and retrieving object pools
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public class ObjectPoolManager {
  private final HashMap<Class, ObjectPool> mObjectPools;
  private final MonotonicClock mClock;

  public ObjectPoolManager(MonotonicClock clock) {
    mObjectPools = new HashMap<Class, ObjectPool>();
    mClock = clock;
  }

  /**
   * Create a new pool builder.  Note that the pool is not actually constructed until
   * ObjectPoolBuilder.build() is called
   * @param clazz the class object for the type which is going to be stored in the pool
   * @param <T> type of object to pool
   * @return a builder object to configure and build the pool
   */
  public <T> ObjectPoolBuilder<T> createPoolBuilder(Class<T> clazz) {
    return new ObjectPoolBuilder<T>(this, clazz, mClock);
  }

  /* package */ <T> void addPool(Class<T> clazz, ObjectPool<T> pool) {
    mObjectPools.put(clazz, pool);
  }

  /**
   * Retrieve the ObjectPool created for the specified class type
   * @param clazz the class object for the type which is pooled
   * @param <T> type of object which is pooled
   * @return an object pool for the given type
   */
  public <T> ObjectPool<T> getPool(Class<T> clazz) {
    return (ObjectPool<T>) mObjectPools.get(clazz);
  }

  /**
   * Convenience method which retrieves the pool and requests an allocation from the pool, returning
   * the allocated object
   * @param clazz the class object for the type which is pooled
   * @param <T> type of object which is pooled
   * @return an instance of the type from the pooler, if it exists
   */
  public <T> T allocate(Class<T> clazz) {
    ObjectPool<T> pool = getPool(clazz);
    if (pool != null) {
      return pool.allocate();
    } else {
      return null;
    }
  }

  /**
   * Convenience method to release an object back to the corresponding pool
   * @param clazz the class object for the type which is pooled
   * @param obj an instance of the type to return to the pooler
   * @param <T> type of the object which is pooled
   */
  public <T> void release(Class<T> clazz, T obj) {
    ObjectPool<T> pool = getPool(clazz);
    if (pool != null) {
      pool.release(obj);
    }
  }
}