org.jactr.core.module.AbstractModule.java Source code

Java tutorial

Introduction

Here is the source code for org.jactr.core.module.AbstractModule.java

Source

/*
 * Created on Aug 14, 2006 Copyright (C) 2001-6, Anthony Harrison anh23@pitt.edu
 * (jactr.org) This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the License,
 * or (at your option) any later version. This library is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
 * the GNU Lesser General Public License for more details. You should have
 * received a copy of the GNU Lesser General Public License along with this
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02111-1307 USA
 */
package org.jactr.core.module;

import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jactr.core.buffer.IActivationBuffer;
import org.jactr.core.concurrent.ExecutorServices;
import org.jactr.core.model.IModel;

public abstract class AbstractModule implements IModule {
    /**
     * logger definition
     */
    static public final Log LOGGER = LogFactory.getLog(AbstractModule.class);

    private IModel _model;

    private String _name;

    private Executor _executor = ExecutorServices.INLINE_EXECUTOR;

    public AbstractModule(String name) {
        _name = name;
    }

    /**
     * @param executor
     */
    protected void setExecutor(Executor executor) {
        _executor = executor;
    }

    /**
     * default executor INLINE_EXECUTOR is used
     * 
     * @return
     */
    public Executor getExecutor() {
        return _executor;
    }

    public void dispose() {
        _model = null;
    }

    public IModel getModel() {
        return _model;
    }

    public String getName() {
        return _name;
    }

    public void install(IModel model) {
        _model = model;
        for (IActivationBuffer buffer : createBuffers())
            _model.addActivationBuffer(buffer);
    }

    /**
     * called to create any buffers used by this buffer. They will be installed
     * into the model by the install(IModel) call
     * 
     * @return
     */
    protected Collection<IActivationBuffer> createBuffers() {
        return Collections.EMPTY_LIST;
    }

    public void uninstall(IModel model) {
        _model = null;
    }

    abstract public void initialize();

    /**
     * return a safe, noncolliding name - calls to this should make sure that the
     * map is readlocked
     * 
     * @param name
     * @param mapping
     * @return
     */
    protected String getSafeName(String name, Map<String, ?> mapping) {
        if (!mapping.containsKey(name.toLowerCase()))
            return name;

        // does the oldName match the name-# pattern
        int lastIndex = -1;
        if ((lastIndex = name.lastIndexOf("-")) != -1) {
            String snippet = name.substring(lastIndex + 1, name.length());
            try {
                /*
                 * if snippet is a number, we cut it off
                 */
                Integer.parseInt(snippet);
                name = name.substring(0, lastIndex);
            } catch (NumberFormatException nfe) {
            }
        }

        StringBuilder sb = new StringBuilder(name);

        if (sb.charAt(sb.length() - 1) != '-')
            sb.append("-");

        sb.append(mapping.size());
        String rtn = sb.toString();

        return rtn;
    }

    static public <T> Future<T> immediateReturn(T value) {
        FutureTask<T> ft = new FutureTask<T>(new Runnable() {
            public void run() {
                // noop
            }
        }, value);
        ft.run();
        return ft;
    }

    /**
     * create a future task and execute it immediately using the INLINE_EXECUTOR
     * 
     * @param <T>
     * @param caller
     * @return
     */
    static public <T> Future<T> immediateFuture(Callable<T> caller) {
        return delayedFuture(caller, ExecutorServices.INLINE_EXECUTOR);
    }

    /**
     * create a future task and execute it on the exector
     * 
     * @param <T>
     * @param caller
     * @param executor
     * @return
     */
    static public <T> Future<T> delayedFuture(Callable<T> caller, Executor executor) {
        FutureTask<T> future = new FutureTask<T>(caller);
        if (executor != null)
            executor.execute(future);
        else
            future.run();

        return future;
    }

}