org.python.core.AutoInternalTables Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython
Jython is an implementation of the high-level, dynamic, object-oriented language Python written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform.
There is a newer version: 2.7.4
Show newest version
// Copyright 2000 Samuele Pedroni

package org.python.core;

import java.lang.ref.*;
import java.util.*;

public abstract class AutoInternalTables extends InternalTables2 {

    protected ReferenceQueue queue = new ReferenceQueue();

    protected abstract Reference newAutoRef(short type, Object key,
                                            Object obj);
    protected abstract short getAutoRefType(Reference ref);
    protected abstract Object getAutoRefKey(Reference ref);

    private synchronized void cleanup() {
        if (this.keepstable >= this.GSTABLE)
         return;
        this.adapters.remove(null); // trick
        Reference ref;
        while ((ref = this.queue.poll()) != null) {
            Object key = getAutoRefKey(ref);
            switch(getAutoRefType(ref)) {
            case JCLASS:
                Class cl = (Class)key;
                this.classes.remove(cl);
                classesDec(cl.getName());
                break;
            case LAZY_JCLASS:
                this.lazyClasses.remove(key);
                break;
            case ADAPTER_CLASS:
                this.adapterClasses.remove(key);
            }
        }
    }


    protected boolean queryCanonical(String name) {
        cleanup();
        return super.queryCanonical(name);
    }

    protected PyJavaClass getCanonical(Class c) {
        cleanup();
        Reference ref = (Reference)classesGet(c);
        if (ref == null) return null;
        return (PyJavaClass)ref.get();
    }

    protected PyJavaClass getLazyCanonical(String name) {
        cleanup();
        Reference ref = (Reference)this.lazyClasses.get(name);
        if (ref == null) return null;
        return (PyJavaClass)ref.get();
    }

    protected void putCanonical(Class c,PyJavaClass canonical) {
        cleanup();
        classesPut(c,newAutoRef(JCLASS,c,canonical));
    }

    protected void putLazyCanonical(String name,PyJavaClass canonical) {
        cleanup();
        this.lazyClasses.put(name,newAutoRef(LAZY_JCLASS,name,canonical));
    }

    protected Class getAdapterClass(Class c) {
        cleanup();
        Reference ref = (Reference)this.adapterClasses.get(c);
        if (ref == null) return null;
        return (Class)ref.get();
    }

    protected void putAdapterClass(Class c,Class ac) {
        cleanup();
        this.adapterClasses.put(c,newAutoRef(ADAPTER_CLASS,c,ac));
    }

    protected Object getAdapter(Object o,String evc) {
        cleanup();
        return super.getAdapter(o,evc);
    }

    protected void putAdapter(Object o,String evc,Object ad) {
        cleanup();
        super.putAdapter(o,evc,ad);
    }


    public boolean _doesSomeAutoUnload() { return true; }

    public void _forceCleanup() { cleanup(); }

    public void _beginCanonical() {
        cleanup();
        super._beginCanonical();
    }

    public void _beginLazyCanonical() {
        cleanup();
        super._beginLazyCanonical();
    }

    public void _beginOverAdapterClasses() {
        cleanup();
        super._beginOverAdapterClasses();

    }

    public void _beginOverAdapters() {
        cleanup();
        super._beginOverAdapters();
    }

    public Object _next() {
        if (this.iterType == ADAPTER) {
            Object ret = super._next();
            if (ret != null) return ret;
        }  else {
            while(this.iter.hasNext()) {
                this.cur = this.iter.next();
                switch(this.iterType) {
                case JCLASS:
                    PyJavaClass jc = (PyJavaClass)((Reference)this.cur).get();
                    if (jc == null ) continue;
                    this.cur = jc;
                    return jc;
                case LAZY_JCLASS:
                    PyJavaClass lazy = (PyJavaClass)((Reference)this.cur).get();
                    if (lazy == null) continue;
                    return new _LazyRep(lazy.__name__,lazy.__mgr__);
                case ADAPTER_CLASS:
                    Map.Entry entry = (Map.Entry)this.cur;
                    if (((Reference)entry.getValue()).get() == null )
                        continue;
                    return entry.getKey();
                }
            }
            this.cur = null;
            this.iter = null;
            endStable();
        }
        cleanup();
        return null;
    }

    public void _flush(PyJavaClass jc) {
        cleanup();
        super._flush(jc);
    }

}