/Users/nah/Documents/code/cast/src/java/cast/architecture/SubarchitectureWorkingMemory.java

Go to the documentation of this file.

/*
 * CAST - The CoSy Architecture Schema Toolkit Copyright (C) 2006-2007
 * Nick Hawes 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., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

package cast.architecture;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import Ice.Current;
import cast.AlreadyExistsOnWMException;
import cast.ConsistencyException;
import cast.DoesNotExistOnWMException;
import cast.UnknownSubarchitectureException;
import cast.cdl.IGNORESAKEY;
import cast.cdl.WMIDSKEY;
import cast.cdl.WorkingMemoryAddress;
import cast.cdl.WorkingMemoryChange;
import cast.cdl.WorkingMemoryChangeFilter;
import cast.cdl.WorkingMemoryEntry;
import cast.cdl.WorkingMemoryEntrySeqHolder;
import cast.cdl.WorkingMemoryOperation;
import cast.cdl.WorkingMemoryPermissions;
import cast.core.CASTUtils;
import cast.core.CASTWMPermissionMap;
import cast.core.CASTWorkingMemory;
import cast.core.CASTWorkingMemoryInterface;
import cast.core.SubarchitectureComponent;
import cast.interfaces.WorkingMemoryPrx;
import cast.interfaces.WorkingMemoryPrxHelper;
import cast.interfaces.WorkingMemoryReaderComponentPrx;
import cast.interfaces.WorkingMemoryReaderComponentPrxHelper;
import cast.interfaces._WorkingMemoryOperations;

public class SubarchitectureWorkingMemory extends SubarchitectureComponent
                implements _WorkingMemoryOperations {

        private final WorkingMemoryChangeFilterMap<String> m_componentFilters;

        private final WorkingMemoryChangeFilterMap<String> m_wmFilters;

        protected final CASTWorkingMemoryInterface m_workingMemory;

        private final HashSet<String> m_ignoreList;

        private boolean m_sendXarchChangeNotifications;

        private final boolean m_wmDistributedFiltering = true;

        private final ReentrantReadWriteLock m_readWriteLock;
        private final Lock m_readLock;
        private final Lock m_writeLock;

        public SubarchitectureWorkingMemory() {
                m_workingMemory = new CASTWorkingMemory();
                m_componentFilters = new WorkingMemoryChangeFilterMap<String>();
                m_wmFilters = new WorkingMemoryChangeFilterMap<String>();
                m_ignoreList = new HashSet<String>();
                m_wmIDs = new HashSet<String>();
                m_permissions = new CASTWMPermissionMap();
                // m_xarchLockConnections = new ConcurrentHashMap<String,
                // PermissionsPullConnectorOut>();

                // determines whether this wm should broadcast to other
                // sub-architectures
                setSendXarchChangeNotifications(true);
                m_readers = new ArrayList<WorkingMemoryReaderComponentPrx>();
                m_workingMemories = new HashMap<String, WorkingMemoryPrx>();
                m_workingMemories_oneway = new HashMap<String, WorkingMemoryPrx>();
                m_readWriteLock = new ReentrantReadWriteLock();
                m_readLock = m_readWriteLock.readLock();
                m_writeLock = m_readWriteLock.writeLock();
        }

        /*
         * (non-Javadoc)
         * 
         * @see
         * cast.core.components.CASTComponentingComponent#configure(java.util.Properties
         * )
         */
        @Override
        protected void configureInternal(java.util.Map<String, String> _config) {
                super.configureInternal(_config);

                String ignore = _config.get(IGNORESAKEY.value);
                if (ignore != null) {
                        String[] ignoreList = ignore.split(",");
                        for (String ignoreMe : ignoreList) {
                                if (ignoreMe.length() > 0) {
                                        ignoreChangesFromSubarchitecture(ignoreMe);
                                }
                        }
                }

                // System.out.println(_config);
                // build lists of component and wm ids
                buildIDLists(_config);

        }

        private final HashSet<String> m_wmIDs;

        private void buildIDLists(Map<String, String> _props) {
                assert (_props != null);
                String wmIDs = _props.get(WMIDSKEY.value);
                assert (wmIDs != null);
                String[] ids = wmIDs.split(",");
                for (String id : ids) {
                        if (id.length() > 0) {
                                m_wmIDs.add(id);
                        }
                }

        }

        protected void addComponentChangeFilter(String _src,
                        WorkingMemoryChangeFilter _data, int _priority) {
                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("SubarchitectureWorkingMemory.addComponentChangeFilter()");
                // debug(_src);
                // debug(CASTUtils.toString(_data));
                // }

                m_componentFilters.put(_data, _src, _priority);

                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("new filters length: " + m_componentFilters.size());
                // debug("only local: " + m_componentFilters.localFiltersOnly());
                // }
        }

        protected void addWMChangeFilter(String _src,
                        WorkingMemoryChangeFilter _data, int _priority) {
                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("SubarchitectureWorkingMemory.addWMChangeFilter()");
                // debug(_src);
                // debug(CASTUtils.toString(_data));
                // }

                m_wmFilters.put(_data, _src, _priority);

                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("new filters length: " + m_wmFilters.size());
                // debug("only local: " + m_wmFilters.localFiltersOnly());
                // }
        }

        // protected void logMemoryChange(WorkingMemoryOperation _op) {
        // synchronized (m_componentStatus) {
        // switch (_op.value()) {
        // case WorkingMemoryOperation._ADD:
        // m_componentStatus.m_changeQueue++;
        // m_componentStatus.m_totalAdds++;
        // break;
        // case WorkingMemoryOperation._OVERWRITE:
        // m_componentStatus.m_totalOverwrites++;
        // break;
        // case WorkingMemoryOperation._DELETE:
        // m_componentStatus.m_changeQueue--;
        // m_componentStatus.m_totalDeletes++;
        // break;
        // default:
        // break;
        // }
        // }
        // }

        private final CASTWMPermissionMap m_permissions;

        private final ArrayList<WorkingMemoryReaderComponentPrx> m_readers;

        protected boolean addToWorkingMemory(String _id, WorkingMemoryEntry _data) {
                boolean result = m_workingMemory.add(_id, _data);
                if (result) {
                        m_permissions.add(_id);
                }
                return result;
        }

        protected void deleteComponentChangeFilter(String _src,
                        WorkingMemoryChangeFilter _data) {
                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("SubarchitectureWorkingMemory.deleteComponentChangeFilter()");
                // debug(_src);
                // debug(CASTUtils.toString(_data));
                // }
                m_componentFilters.remove(_data);
                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("new filters length: " + m_componentFilters.size());
                // debug("only local: " + m_componentFilters.localFiltersOnly());
                // }
        }

        protected void deleteWMChangeFilter(String _src,
                        WorkingMemoryChangeFilter _data) {
                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("SubarchitectureWorkingMemory.deleteWMChangeFilter()");
                // debug(_src);
                // debug(CASTUtils.toString(_data));
                // }
                m_wmFilters.remove(_data);
                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                // debug("new filters length: " + m_wmFilters.size());
                // debug("only local: " + m_wmFilters.localFiltersOnly());
                // }
        }

        protected WorkingMemoryEntry deleteFromWorkingMemory(String _id,
                        String _component) throws DoesNotExistOnWMException {

                if (!m_workingMemory.contains(_id)) {
                        throw new DoesNotExistOnWMException(
                                        "Entry does not exist for deleting: " + _id,
                                        new WorkingMemoryAddress(_id, getSubarchitectureID()));
                }

                boolean isLocked = false;

                if (m_permissions.isLocked(_id)) {

                        log(_component + " has found this to be locked " + _id);
                        
                        WorkingMemoryPermissions permissions = m_permissions
                                        .getPermissions(_id);

                        // if the item is delete locked
                        if (!CASTUtils.deleteAllowed(permissions)) {
                                // we're going to assume that client checking is up to scratch
                                assert (m_permissions.isLockHolder(_id, _component));
                                log(_component + " is NOT allowed to delete " + _id);
                        } else {
                                // could just be an overwrite lock, in which case it doesn't
                                // matter who is the lock holder
                                log(_component + " is allowed to delete " + _id);
                        }

                        isLocked = true;
                }

                WorkingMemoryEntry result = m_workingMemory.remove(_id);
                log(_component + " deleted " + _id);

                if (isLocked) {
                        log("unlocking on deletion: " + _id);
                        m_permissions.unlock(_id, _component);
                }

                try {
                        m_permissions.remove(_id);
                } catch (InterruptedException e) {
                        logException(e);
                }

                return result;
        }

        private void readBlock(String _id, String _component) {

                WorkingMemoryPermissions perms = m_permissions.getPermissions(_id);

                while (m_permissions.isLocked(_id)
                                && !m_permissions.isLockHolder(_id, _component)
                                && !CASTUtils.readAllowed(perms)) {

                        debug("blocking read by " + _component + " because " + _id
                                        + " is locked by " + m_permissions.getLockHolder(_id));
                        // block
                        try {

                                // unlock before we block to allow other things to
                                // happen
                                m_readLock.unlock();
                                debug("UNLOCKED readLock blocking read by " + _component
                                                + " because " + _id + " is locked by "
                                                + m_permissions.getLockHolder(_id));

                                m_permissions.lock(_id, _component,
                                                WorkingMemoryPermissions.LOCKEDODR);

                                debug("LOCKED PERMISSIONS  blocking read by " + _component
                                                + " because " + _id + " is locked by "
                                                + m_permissions.getLockHolder(_id));

                                // relock to finish the operation
                                m_readLock.lock();

                                debug("LOCKED readLock blocking read by " + _component
                                                + " because " + _id + " is locked by "
                                                + m_permissions.getLockHolder(_id));

                                // then unlock
                                m_permissions.unlock(_id, _component);

                                debug("UNLOCKED permissions blocking read by " + _component
                                                + " because " + _id + " is locked by "
                                                + m_permissions.getLockHolder(_id));

                        } catch (InterruptedException e) {
                                println(e);
                        }

                        // now check if entry still exists as it could've been deleted
                        // while we block... so we don't even hold a lock
                        if (!m_workingMemory.contains(_id)) {
                                debug("deletion during readBlock, returning");
                                return;
                        }

                        perms = m_permissions.getPermissions(_id);

                }
        }

        protected boolean isAllowedChange(WorkingMemoryChange _change) {
                return (!m_ignoreList.contains(_change.address.subarchitecture))
                                && m_componentFilters.allowsChange(_change);
        }

        protected boolean isSendingXarchChangeNotifications() {
                return m_sendXarchChangeNotifications;
        }

        protected boolean overwriteWorkingMemory(String _id,
                        WorkingMemoryEntry _data, String _component)
                        throws DoesNotExistOnWMException {

                if (!m_workingMemory.contains(_id)) {
                        throw new DoesNotExistOnWMException(
                                        "Entry does not exist for overwriting: " + _id,
                                        new WorkingMemoryAddress(_id, getSubarchitectureID()));
                }

                // sanity check locking elsewhere
                if (m_permissions.isLocked(_id)) {
                        WorkingMemoryPermissions permissions = m_permissions
                                        .getPermissions(_id);

                        // if the item is delete locked
                        if (!CASTUtils.overwriteAllowed(permissions)) {
                                // we're going to assume that client checking is up to scratch
                                assert (m_permissions.isLockHolder(_id, _component));
                        } else {
                                // this is never going to happen as all locks are overwrite
                                // locks
                        }
                }

                boolean result = m_workingMemory.overwrite(_id, _data);

                // if (result) {
                // logMemoryChange(WorkingMemoryOperation.OVERWRITE);
                // }

                return result;

        }

        protected void printMemoryContents() {
                println(m_workingMemory.toString());
        }

        protected void setSendXarchChangeNotifications(
                        boolean sendXarchChangeNotifications) {
                m_sendXarchChangeNotifications = sendXarchChangeNotifications;
        }

        private WorkingMemoryEntry getEntryByID(String _id, String _component)
                        throws DoesNotExistOnWMException {
                WorkingMemoryEntry entry = null;
                if (m_workingMemory.contains(_id)) {
                        // block if necessary
                        readBlock(_id, _component);
                        // and it might have

                        entry = m_workingMemory.get(_id);
                        if (entry != null) {
                                return entry;
                        } else {
                                debug("Entry was deleted during readBlock: " + _id);
                        }
                }

                throw new DoesNotExistOnWMException("Entry does not exist: " + _id,
                                new WorkingMemoryAddress(_id, getSubarchitectureID()));
        }

        // private int getOverwriteCount(String _id) {
        // int updateCount = -1;
        // // sanity check first
        // if (m_workingMemory.hasContained(_id)) {
        // updateCount = m_workingMemory.getOverwriteCount(_id);
        // }
        // return updateCount;
        // }

        private void signalChange(WorkingMemoryOperation _op, String _src,
                        String _id, String _type, String[] _typeHierarchy) {

                WorkingMemoryChange wmc = new WorkingMemoryChange(_op, _src,
                                new WorkingMemoryAddress(_id, getSubarchitectureID()), _type,
                                _typeHierarchy, getCASTTime());

                // if (m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                debug("SAWN.sigCh: " + CASTUtils.toString(wmc));
                // }

                // signal change locally if allowed
                if (isAllowedChange(wmc)) {
                        // send locally
                        for (WorkingMemoryReaderComponentPrx reader : m_readers) {
                                reader.receiveChangeEvent(wmc);
                        }
                } else {
                        // debug("SAWN.sigCh: not sending locally");
                }

                // signal change across sub-architectures where appropriate
                if (isSendingXarchChangeNotifications()) {
                        for (String wmID : m_workingMemories_oneway.keySet()) {
                                // debug("SAWN.sigCh: send to?: " + wmID);

                                if (isAllowedChange(wmID, wmc)) {
                                        // log("SubarchitectureWorkingMemory.signalChange(): " +
                                        // wmID);
                                        m_workingMemories_oneway.get(wmID).receiveChangeEvent(wmc);
                                }
                        }
                }
        }

        protected boolean isAllowedChange(String _wmID, WorkingMemoryChange _wmc) {
                Queue<String> receivers = new LinkedList<String>();
                // get all receivers for this change
                m_wmFilters.get(_wmc, receivers);
                // if the given id is a recevier, then go ahead
                return receivers.contains(_wmID);
        }

        void ignoreChangesFromSubarchitecture(String _subarch) {

                log("ignoring changes from: " + _subarch);
                m_ignoreList.add(_subarch);
        }

        public void addReader(WorkingMemoryReaderComponentPrx _reader,
                        Current __current) {
                // convert to one-way proxies for speed
                m_readers.add(WorkingMemoryReaderComponentPrxHelper
                                .uncheckedCast(_reader.ice_oneway()));

        }

        private final WorkingMemoryPrx getWorkingMemory(String _subarch)
                        throws UnknownSubarchitectureException {
                WorkingMemoryPrx wm = m_workingMemories.get(_subarch);
                if (wm == null) {
                        throw new UnknownSubarchitectureException(
                                        "Unknown subarchitecture: " + _subarch, _subarch);
                }
                return wm;
        }

        private final HashMap<String, WorkingMemoryPrx> m_workingMemories;
        private final HashMap<String, WorkingMemoryPrx> m_workingMemories_oneway;

        public void addToWorkingMemory(String _id, String _subarch, String _type,
                        String _component, Ice.Object _entry, Current __current)
                        throws AlreadyExistsOnWMException, UnknownSubarchitectureException {

                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        // if it already exists complain bitterly
                        if (m_workingMemory.contains(_id)) {
                                throw new AlreadyExistsOnWMException(
                                                "Entry already exists on WM. Was trying to write id "
                                                                + _id + " in subarchitecture " + _subarch,
                                                new WorkingMemoryAddress(_id, _subarch));

                        }
                        // else get stuck in
                        else {
                                // fine then
                                m_writeLock.lock();
                                boolean result = addToWorkingMemory(_id,
                                                new WorkingMemoryEntry(_id, _type, 0, _entry));
                                // sanity check
                                assert (result);

                                signalChange(WorkingMemoryOperation.ADD, _component, _id,
                                                _type, _entry.ice_ids());
                                m_writeLock.unlock();

                        }
                } else {
                        // get the correct wm and query that instead
                        getWorkingMemory(_subarch).addToWorkingMemory(_id, _subarch, _type,
                                        _component, _entry);
                }

        }

        public void deleteFromWorkingMemory(String _id, String _subarch,
                        String _component, Current __current)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        log(_component + " going to delete " + _id);
                        m_writeLock.lock();
                        log(_component + " got write lock");
                        WorkingMemoryEntry entry;
                        try {
                                entry = deleteFromWorkingMemory(_id, _component);
                                log(_component + " done delete");
                                // sanity check
                                assert (entry != null);
                                signalChange(WorkingMemoryOperation.DELETE, _component, _id,
                                                entry.type, entry.entry.ice_ids());

                        } finally {
                                m_writeLock.unlock();
                        }
                } else {
                        // send on to the one that really cares
                        getWorkingMemory(_subarch).deleteFromWorkingMemory(_id, _subarch,
                                        _component);
                }
        }

        public boolean exists(String _id, String _subarch, Current __current)
                        throws UnknownSubarchitectureException {
                if (getSubarchitectureID().equals(_subarch)) {
                        m_readLock.lock();
                        boolean result = m_workingMemory.contains(_id);
                        m_readLock.unlock();
                        return result;
                } else {
                        // send on to the one that really cares
                        return getWorkingMemory(_subarch).exists(_id, _subarch);
                }
        }

        public WorkingMemoryPermissions getPermissions(String _id, String _subarch,
                        Current __current) throws DoesNotExistOnWMException,
                        UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {

                        m_readLock.lock();
                        boolean contains = m_workingMemory.contains(_id);
                        // if it exists, then return a value
                        if (contains) {
                                WorkingMemoryPermissions permissions = m_permissions
                                                .getPermissions(_id);
                                m_readLock.unlock();
                                return permissions;
                        }
                        // else kick up a fuss
                        else {
                                m_readLock.unlock();
                                throw new DoesNotExistOnWMException(
                                                "Entry does not exist on wm. Was looking in subarch "
                                                                + _subarch + " for id " + _id,
                                                new WorkingMemoryAddress(_id, _subarch));
                        }
                } else {
                        // get the correct wm and query that instead
                        // send on to the one that really cares
                        return getWorkingMemory(_subarch).getPermissions(_id, _subarch);
                }

        }

        public int getVersionNumber(String _id, String _subarch, Current __current)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        m_readLock.lock();
                        boolean contained = m_workingMemory.hasContained(_id);
                        // if it has once existed, then return a value
                        if (contained) {
                                int overwriteCount = m_workingMemory.getOverwriteCount(_id);
                                m_readLock.unlock();
                                return overwriteCount;
                        }
                        // else kick up a fuss
                        else {
                                m_readLock.unlock();
                                throw new DoesNotExistOnWMException(
                                                "Entry has never existed on wm. Was looking in subarch "
                                                                + _subarch + " for id " + _id,
                                                new WorkingMemoryAddress(_id, _subarch));
                        }
                } else {
                        // send on to the one that really cares
                        return getWorkingMemory(_subarch).getVersionNumber(_id, _subarch);
                }

        }

        public void getWorkingMemoryEntries(String _type, String _subarch,
                        int _count, String _component,
                        WorkingMemoryEntrySeqHolder _entries, Current __current)
                        throws UnknownSubarchitectureException {

                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        if (_entries.value == null) {
                                _entries.value = new ArrayList<WorkingMemoryEntry>();
                        }
                        m_readLock.lock();
                        getWorkingMemoryEntries(_type, _count, _component, _entries.value);
                        m_readLock.unlock();

                } else {
                        // send on to the one that really cares
                        getWorkingMemory(_subarch).getWorkingMemoryEntries(_type, _subarch,
                                        _count, _component, _entries);
                }

        }

        private void getWorkingMemoryEntries(String _type, int _count,
                        String _component, List<WorkingMemoryEntry> _entries) {
                ArrayList<String> ids = m_workingMemory.getIDsByType(_type, _count);
                for (int i = 0; i < ids.size(); i++) {
                        try {
                                _entries.add(getEntryByID(ids.get(i), _component));
                        } catch (DoesNotExistOnWMException e) {
                                // ignore for type-based queries
                        }
                }
        }

        public WorkingMemoryEntry getWorkingMemoryEntry(String _id,
                        String _subarch, String _component, Current __current)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        // println("local query");
                        m_readLock.lock();
                        WorkingMemoryEntry entry;
                        try {
                                entry = getEntryByID(_id, _component);
                        } finally {
                                m_readLock.unlock();
                        }
                        return entry;
                } else {
                        // println("remote query");
                        // send on to the one that really cares
                        return getWorkingMemory(_subarch).getWorkingMemoryEntry(_id,
                                        _subarch, _component);
                }

        }

        public void lockEntry(String _id, String _subarch, String _component,
                        WorkingMemoryPermissions _perm, Current __current)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {

                        // first gain a lock... using the shared lock as the only
                        // state-changing act is internally synchronised anyway

                        debug(CASTUtils.concatenate(_component," locking: ",_id));

                        m_readLock.lock();
//                      log(_component + " got read lock");

                        if (m_workingMemory.contains(_id)) {

//                              log(_component + " contains == true");

                                try {
                                        // now unlock incase the WM locking blocks
                                        m_readLock.unlock();

//                                      log(_component + " attempting lock");
                                        
                                        m_permissions.lock(_id, _component, _perm);
//                                      debug(_component + " achieved lock");

                                } catch (InterruptedException e) {
                                        logException(e);
                                } finally {
                                        // relock so we're back in control

                                        m_readLock.lock();
//                                      log(_component + " got read lock back");
                                }

                                // now check that it still exists, because it could've been
                                // deleted before the lock was released
                                if (!m_workingMemory.contains(_id)) {
//                                      log(_component + " - entry was deleted in meantime");
                                        m_permissions.unlock(_id, _component);
                                        m_readLock.unlock();
                                        throw new DoesNotExistOnWMException(
                                                        "Entry deleted while waiting for lock. Component "
                                                                        + _component + "  was looking in subarch "
                                                                        + _subarch + " for id " + _id,
                                                        new WorkingMemoryAddress(_id, _subarch));
                                } else {
                                        assert (m_permissions.isLockHolder(_id, _component));
                                        assert (m_permissions.getPermissions(_id) == _perm);
                                        // debug("%s locked: ok",_component.c_str());
                                }
                        }
                        // else kick up a fuss
                        else {
                                m_readLock.unlock();
//                              log(_component + " contains != true");

                                throw new DoesNotExistOnWMException(
                                                "Entry does not exist to lock. Component " + _component
                                                                + "  was looking in subarch " + _subarch
                                                                + " for id " + _id, new WorkingMemoryAddress(
                                                                _id, _subarch));
                        }

                        m_readLock.unlock();

                } else {
                        getWorkingMemory(_subarch).lockEntry(_id, _subarch, _component,
                                        _perm);
                }

        }

        public void overwriteWorkingMemory(String _id, String _subarch,
                        String _type, String _component, Ice.Object _entry,
                        Current __current) throws DoesNotExistOnWMException,
                        UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        m_writeLock.lock();
                        // DANGER this might produce an exception... change to critical
                        // section
                        boolean result;
                        try {
                                result = overwriteWorkingMemory(_id, new WorkingMemoryEntry(
                                                _id, _type, 0, _entry), _component);
                                // sanity check
                                assert (result);
                                signalChange(WorkingMemoryOperation.OVERWRITE, _component, _id,
                                                _type, _entry.ice_ids());

                        } finally {
                                m_writeLock.unlock();
                        }
                } else {
                        // send on to the one that really cares
                        getWorkingMemory(_subarch).overwriteWorkingMemory(_id, _subarch,
                                        _type, _component, _entry);
                }

        }

        public void receiveChangeEvent(WorkingMemoryChange _wmc, Current __current) {
                lockComponent();

                // if the filters require external changes, allow them to be
                // forwarded
                if (!m_componentFilters.localFiltersOnly()) {

                        // if(m_logger.getLevel().isGreaterOrEqual(Level.TRACE)) {
                        // ostringstream outStream;
                        // outStream<<"forwarding change: "<<wmc;
                        // debug(outStream.str());
                        // }

                        for (WorkingMemoryReaderComponentPrx reader : m_readers) {
                                reader.receiveChangeEvent(_wmc);
                        }

                }

                unlockComponent();

        }

        public void registerComponentFilter(WorkingMemoryChangeFilter _filter,
                        int _priority, Current __current) {
                debug("SubarchitectureWorkingMemory.registerComponentFilter()");
                m_componentFilters.put(_filter, _filter.origin, _priority);

                // cout<<"new filters length: "<<m_componentFilters.size()<<endl;
                // cout<<"only local: "<<m_componentFilters.localFiltersOnly()<<endl;

                if (m_wmDistributedFiltering) {
                        // debug("fowarding filter");
                        // sendFilter(_filter);
                        for (String sa : m_workingMemories.keySet()) {
                                m_workingMemories.get(sa).registerWorkingMemoryFilter(_filter,
                                                getSubarchitectureID(), _priority);
                        }
                }

        }

        public void registerWorkingMemoryFilter(WorkingMemoryChangeFilter _filter,
                        String _subarch, int _priority, Current __current) {
                debug("SubarchitectureWorkingMemory.registerWorkingMemoryFilter()");
                // debug("SubarchitectureWorkingMemory::addWMChangeFilter()");
                // ostringstream outStream;
                // outStream<<_filter;
                // debug(outStream.str());
                // log("SubarchitectureWorkingMemory.registerWorkingMemoryFilter(): " +
                // _subarch);
                m_wmFilters.put(_filter, _subarch, _priority);

                // cout<<"new filters length: "<<m_wmFilters.size()<<endl;
                // cout<<"only local: "<<m_wmFilters.localFiltersOnly()<<endl;
        }

        public void removeComponentFilter(WorkingMemoryChangeFilter _filter,
                        Current __current) {
                // debug("SubarchitectureWorkingMemory::deleteComponentChangeFilter()");
                // debug(_src);
                // ostringstream outStream;
                // outStream<<_filter;
                // debug(outStream.str());

                m_componentFilters.remove(_filter);

                // cout<<"new filters length: "<<m_componentFilters.size()<<endl;
                // cout<<"only local: "<<m_componentFilters.localFiltersOnly()<<endl;

                for (WorkingMemoryPrx wm : m_workingMemories.values()) {
                        wm.removeWorkingMemoryFilter(_filter);
                }

        }

        public void removeWorkingMemoryFilter(WorkingMemoryChangeFilter _filter,
                        Current __current) {
                // debug("SubarchitectureWorkingMemory::deleteWMChangeFilter()");
                // debug(_src);
                // ostringstream outStream;
                // outStream<<_filter;
                // debug(outStream.str());

                m_wmFilters.remove(_filter);

                // cout<<"new filters length: "<<m_wmFilters.size()<<endl;
                // cout<<"only local: "<<m_wmFilters.localFiltersOnly()<<endl;
        }

        public void setWorkingMemory(WorkingMemoryPrx _wm, String _subarch,
                        Current __current) {
                // println("setting: \"" + _subarch + "\"");
                m_workingMemories.put(_subarch, _wm);
                m_workingMemories_oneway.put(_subarch,
                                WorkingMemoryPrxHelper.uncheckedCast(_wm.ice_oneway()));
        }

        public boolean tryLockEntry(String _id, String _subarch, String _component,
                        WorkingMemoryPermissions _perm, Current __current)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        //
                        if (m_workingMemory.contains(_id)) {
                                try {
                                        if (m_permissions.tryLock(_id, _component, _perm)) {
                                                // debug("%s try locked: %s",_component.c_str(),_id.c_str());
                                                assert (m_permissions.isLockHolder(_id, _component));
                                                assert (m_permissions.getPermissions(_id) == _perm);
                                                // debug("%s try locked: ok",_component.c_str());
                                                return true;
                                        }
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                                return false;
                        }
                        // else kick up a fuss
                        else {
                                throw new DoesNotExistOnWMException(
                                                "Entry does not exist for try-locking. Was looking in subarch "
                                                                + _subarch + " for id " + _id,
                                                new WorkingMemoryAddress(_id, _subarch));
                        }
                } else {
                        // get the correct wm and query that instead
                        return getWorkingMemory(_subarch).tryLockEntry(_id, _subarch,
                                        _component, _perm);
                }
        }

        public void unlockEntry(String _id, String _subarch, String _component,
                        Current __current) throws ConsistencyException,
                        DoesNotExistOnWMException, UnknownSubarchitectureException {
                // if this is for me
                if (getSubarchitectureID().equals(_subarch)) {
                        //

                        m_readLock.lock();

                        if (m_workingMemory.contains(_id)) {

                                // this wasn't in the original design, but seems necessary now
                                // we can do this at wm level
                                if (!m_permissions.isLocked(_id)) {
                                        m_readLock.unlock();
                                        throw new ConsistencyException("Entry is not locked. "
                                                        + _component + " was looking in subarch "
                                                        + _subarch + " for id " + _id,
                                                        new WorkingMemoryAddress(_id, _subarch));
                                } else if (!m_permissions.getLockHolder(_id).equals(_component)) {
                                        m_readLock.unlock();
                                        throw new ConsistencyException("Entry is locked, but by "
                                                        + m_permissions.getLockHolder(_id) + " not  "
                                                        + _component + ", who was looking in subarch"
                                                        + _subarch + " for id " + _id,
                                                        new WorkingMemoryAddress(_id, _subarch));
                                }

                                m_permissions.unlock(_id, _component);
                                // debug("%s unlocked %s",_component.c_str(),_id.c_str());
                        }
                        // else kick up a fuss
                        else {
                                m_readLock.unlock();
                                throw new DoesNotExistOnWMException(
                                                "Entry does not exist for unlocking. Was looking in subarch "
                                                                + _subarch + " for id " + _id,
                                                new WorkingMemoryAddress(_id, _subarch));
                        }

                        m_readLock.unlock();

                } else {
                        // get the correct wm and query that instead
                        getWorkingMemory(_subarch).unlockEntry(_id, _subarch, _component);
                }

        }

}

---