Quadcap Embeddable Database

com/quadcap/sql/lock/ObjectPool.java

Go to the documentation of this file.

package com.quadcap.sql.lock;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.util.Iterator;

import com.quadcap.util.Debug;

//#set defs(NOPOOLxx) 1
//#autogen begin
//#autogen end

/**
 * 
 *
 * @author Stan Bailes
 */
public class ObjectPool {
    PooledObject                        proto;

    public ObjectPool(PooledObject proto) {
        this.proto = proto;
    }

    //#ifdef NOPOOL
//-    public PooledObject get() {
//-        PooledObject p = proto.create();
//-        p.live = true;
//-        return p;
//-    }
//-    public void release(PooledObject p) {
//-        p.live = false;
//-    }
//-    public Iterator iterator() { return null; }
    //#else
    PooledObject[]                      pool;
    int                                 next    = 0;
    
    Object lock = new Object();
    
    final void resizePool(int lim) {
        PooledObject[] old = pool;
        if (old == null || old.length != lim) {
            pool = new PooledObject[lim];
            int f = 0;
            if (old != null) {
                System.arraycopy(old, 0, pool, 0,
                                 Math.min(old.length, lim));
                f = old.length;
            }
            for (int i = f; i < lim; i++) {
                pool[i] = proto.create();
                pool[i].poolIndex = i;
            }
        }
    }
    
    public PooledObject get() {
        synchronized (lock) {
            if (pool == null || next >= pool.length) {
                resizePool(pool == null ?
                           8 : (pool.length + (pool.length >> 2)));
            }
            PooledObject obj = pool[next++];
            if (obj.live) throw new RuntimeException("Already live: " + obj);
            obj.live = true;
            return obj;
        }
    }

    public void release(PooledObject obj) {
        synchronized (lock) {
            if (!obj.live) throw new RuntimeException("Not live: " + obj);
            obj.live = false;
            final int idx = obj.poolIndex;
            if (pool[idx] != obj)
                throw new RuntimeException("Pool check: " + obj);
            final int last = --next;
            if (idx != last) {
                pool[idx] = pool[last];
                pool[idx].poolIndex = idx;
                pool[last] = obj;
                obj.poolIndex = last;
            }
        }
    }

    /**
     * Return an Iterator that can be used to access all live objects
     * in the pool.
     */
    public Iterator iterator() {
        return new Iterator() {
                int idx = 0;
                
                public boolean hasNext() {
                    return idx < next;
                }

                public Object next() {
                    return idx < next ? pool[idx++] : null;
                }
                public void remove() {}
            };
    }    
            
    //#ifdef DEBUG
    public String toString() {
        String s = getClass().getName();
        int idx = s.lastIndexOf('.');
        if (idx >= 0) s = s.substring(idx+1);
        StringBuffer sb = new StringBuffer(s);
        sb.append("(");
        int len = s.length() + 1; // s + '['
        for (int i = 0; i < next; i++) {
            if (i > 0) sb.append(',');
            String p = pool[i].toString();
            final int plen = p.length();
            len += plen + 1;
            if (len > 80) {
                sb.append('\n');
                len = plen;
            }
            sb.append(p);
        }
        sb.append(')');
        return sb.toString();
    }
    //#endif
    //#endif
}