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

Go to the documentation of this file.

package cast.architecture;

import java.util.Hashtable;
import java.util.Map;

import org.apache.log4j.Logger;

import Ice.Current;
import cast.ConsistencyException;
import cast.DoesNotExistOnWMException;
import cast.UnknownSubarchitectureException;
import cast.WMException;
import cast.cdl.WorkingMemoryAddress;
import cast.cdl.WorkingMemoryPermissions;
import cast.core.CASTComponentPermissionsMap;
import cast.core.CASTUtils;
import cast.core.SubarchitectureComponent;
import cast.interfaces.WorkingMemoryPrx;
import cast.interfaces.WorkingMemoryPrxHelper;
import cast.interfaces._WorkingMemoryAttachedComponentOperations;

public abstract class WorkingMemoryAttachedComponent extends
                SubarchitectureComponent implements
                _WorkingMemoryAttachedComponentOperations {

        protected WorkingMemoryPrx m_workingMemory;

        public void setWorkingMemory(WorkingMemoryPrx _wm, Current __current) {
                assert (_wm != null);
                m_workingMemory = _wm;
        }

        private final Hashtable<String, Integer> m_versionNumbers;

        private CASTComponentPermissionsMap m_permissions;

        public WorkingMemoryAttachedComponent() {
                m_versionNumbers = new Hashtable<String, Integer>();
        }

        //
        @Override
        protected void configureInternal(Map<String, String> _config) {
                super.configureInternal(_config);
                m_permissions = new CASTComponentPermissionsMap(getSubarchitectureID());
        }

        public final boolean existsOnWorkingMemory(String _id) {

                try {
                        return existsOnWorkingMemory(_id, getSubarchitectureID());
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        public final boolean existsOnWorkingMemory(String _id, String _subarch)
                        throws UnknownSubarchitectureException {

                assert _id.length() > 0 : "id must not be empty";
                assert _subarch.length() > 0 : "subarchitecture id must not be empty";
                assert m_workingMemory != null;

                return m_workingMemory.exists(_id, _subarch);

        }

        public final boolean existsOnWorkingMemory(WorkingMemoryAddress _wma)
                        throws UnknownSubarchitectureException {
                return existsOnWorkingMemory(_wma.id, _wma.subarchitecture);
        }

        public final int getVersionNumber(String _id)
                        throws DoesNotExistOnWMException {
                try {
                        return getVersionNumber(_id, getSubarchitectureID());
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        public int getVersionNumber(String _id, String _subarch)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {

                assert _id.length() > 0 : "id must not be empty";
                assert _subarch.length() > 0 : "subarchitecture id must not be empty";
                assert m_workingMemory != null;

                return m_workingMemory.getVersionNumber(_id, _subarch);
        }

        public int getVersionNumber(WorkingMemoryAddress _wma)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                return getVersionNumber(_wma.id, _wma.subarchitecture);
        }

        protected final void storeVersionNumber(String _id, int _version) {
                m_versionNumbers.put(_id, _version);
        }

        public final int getStoredVersionNumber(String _id)
                        throws ConsistencyException {

                Integer v = m_versionNumbers.get(_id);
                if (v == null) {
                        throw new ConsistencyException("No stored version for id: " + _id,
                                        new WorkingMemoryAddress(_id, getSubarchitectureID()));
                } else {
                        return v;
                }
        }

        protected final void startVersioning(String _id) {
                assert (!isVersioned(_id));
                storeVersionNumber(_id, 0);
        }

        protected final void updateVersion(String _id, int _newVersion) {
                // if (m_bDebugOutput) {
                // try {
                // debug("updateVersion: " + _id + " "
                // + getStoredVersionNumber(_id) + " -> " + _newVersion);
                // } catch (ConsistencyException e) {
                // debug(e.getMessage());
                // }
                // }
                storeVersionNumber(_id, _newVersion);
        }

        protected final void increaseStoredVersion(String _id)
                        throws ConsistencyException {
                int stored = getStoredVersionNumber(_id);
                updateVersion(_id, ++stored);
        }

        public final boolean isVersioned(String _id) {
                return m_versionNumbers.containsKey(_id);
        }

        protected final void stopVersioning(String _id) {
                if (isVersioned(_id)) {
                        removeVersionNumber(_id);
                }
        }

        protected final void removeVersionNumber(String _id) {
                m_versionNumbers.remove(_id);
        }

        public final boolean haveLatestVersion(String _id)
                        throws ConsistencyException, DoesNotExistOnWMException {
                assert (isVersioned(_id));

                int ownedVersion = getStoredVersionNumber(_id);
                int wmVersion = getVersionNumber(_id);

                return wmVersion == ownedVersion;
        }

        public final void checkConsistency(String _id) throws ConsistencyException,
                        DoesNotExistOnWMException {
                try {
                        checkConsistency(_id, getSubarchitectureID());
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        public void checkConsistency(String _id, String _subarch)
                        throws ConsistencyException, DoesNotExistOnWMException,
                        UnknownSubarchitectureException {

                if (!isVersioned(_id)) {
                        throw new ConsistencyException("!isVersioned(" + _id
                                        + ") in subarch " + _subarch, new WorkingMemoryAddress(_id,
                                        _subarch));
                }

                if (!haveLatestVersion(_id, _subarch)) {
                        throw new ConsistencyException(
                                        "You have attempted to overwrite an outdated working memory entry. Please reread and try again. WMA: "
                                                        + _id
                                                        + ":"
                                                        + _subarch
                                                        + ". Local version: "
                                                        + getStoredVersionNumber(_id)
                                                        + ". WM version: "
                                                        + getVersionNumber(_id, _subarch),
                                        new WorkingMemoryAddress(_id, _subarch));
                }

        }

        public boolean haveLatestVersion(String _id, String _subarch)
                        throws ConsistencyException, DoesNotExistOnWMException,
                        UnknownSubarchitectureException {
                assert (isVersioned(_id));

                int ownedVersion = getStoredVersionNumber(_id);
                int wmVersion = getVersionNumber(_id, _subarch);

                debug("id: " + _id + "own: " + ownedVersion + " wm: " + wmVersion);
                return wmVersion == ownedVersion;
        }

        public void checkConsistency(WorkingMemoryAddress _wma)
                        throws ConsistencyException, DoesNotExistOnWMException,
                        UnknownSubarchitectureException {
                checkConsistency(_wma.id, _wma.subarchitecture);
        }

        public void lockEntry(String _id, String _subarch,
                        WorkingMemoryPermissions _permissions)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {

                assert _id.length() != 0 : "id must not be empty";
                assert _subarch.length() != 0 : "sa must not be empty";
                assert m_workingMemory != null;

                // will throw here if doesn't exist
                m_workingMemory
                                .lockEntry(_id, _subarch, getComponentID(), _permissions);
                m_permissions.setPermissions(_id, _subarch, _permissions);
        }

        public void lockEntry(WorkingMemoryAddress _wma,
                        WorkingMemoryPermissions _permissions)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                lockEntry(_wma.id, _wma.subarchitecture, _permissions);
        }

        public void unlockEntry(WorkingMemoryAddress _wma)
                        throws ConsistencyException, DoesNotExistOnWMException,
                        UnknownSubarchitectureException {
                unlockEntry(_wma.id, _wma.subarchitecture);
        }

        public void unlockEntry(String _id, String _subarch)
                        throws ConsistencyException, DoesNotExistOnWMException,
                        UnknownSubarchitectureException {
                assert _id.length() != 0 : "id must not be empty";
                assert _subarch.length() != 0 : "sa must not be empty";
                assert m_workingMemory != null;

                // if we don't hold the lock, then don't do anything
                if (!holdsLock(_id, _subarch)) {
                        debug("no lock held for: " + _id + ":" + _subarch);
                        return;
                }

                assert (_id.length() != 0);// id must not be empty

                // unlock entry... will throw if entry does not exist or locks are wrong
                m_workingMemory.unlockEntry(_id, _subarch, getComponentID());

                m_permissions.removePermissions(_id, _subarch);

                // just check up on ourselves
                assert (!holdsLock(_id, _subarch));

        }

        public boolean tryLockEntry(String _id, String _subarch,
                        WorkingMemoryPermissions _permissions)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                assert _id.length() != 0 : "id must not be empty";
                assert _subarch.length() != 0 : "sa must not be empty";
                assert m_workingMemory != null;

                // will throw here if doesn't exist
                boolean succeeded = m_workingMemory.tryLockEntry(_id, _subarch,
                                getComponentID(), _permissions);

                // if we succeeded, then let's store the permissions
                if (succeeded) {
                        m_permissions.setPermissions(_id, _subarch, _permissions);
                }

                return succeeded;

        }

        public boolean tryLockEntry(WorkingMemoryAddress _wma,
                        WorkingMemoryPermissions _permissions)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                return tryLockEntry(_wma.id, _wma.subarchitecture, _permissions);
        }

        public WorkingMemoryPermissions getPermissions(String _id, String _subarch)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                assert _id.length() != 0 : "_id must not be empty";
                assert _subarch.length() != 0 : "_subarch must not be empty";
                return m_workingMemory.getPermissions(_id, _subarch);
        }

        public WorkingMemoryPermissions getPermissions(WorkingMemoryAddress _wma)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                return getPermissions(_wma.id, _wma.subarchitecture);
        }

        public boolean isOverwritable(String _id, String _subarch)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                if (holdsOverwriteLock(_id, _subarch)) {
                        return true;
                } else {
                        WorkingMemoryPermissions permissions = getPermissions(_id, _subarch);
                        // debug("isOverwritable: " + CASTUtils.toString(permissions) + " "
                        // + CASTUtils.overwriteAllowed(permissions));
                        return CASTUtils.overwriteAllowed(permissions);
                }
        }

        public boolean isDeletable(String _id, String _subarch)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                if (holdsDeleteLock(_id, _subarch)) {
                        return true;
                } else {
                        WorkingMemoryPermissions permissions = getPermissions(_id, _subarch);
                        return CASTUtils.deleteAllowed(permissions);
                }
        }

        public boolean isReadable(String _id, String _subarch)
                        throws DoesNotExistOnWMException, UnknownSubarchitectureException {
                if (holdsReadLock(_id, _subarch)) {
                        return true;
                } else {
                        WorkingMemoryPermissions permissions = getPermissions(_id, _subarch);
                        return CASTUtils.readAllowed(permissions);
                }
        }

        public void unlockEntry(String _id) throws ConsistencyException,
                        DoesNotExistOnWMException {
                try {
                        unlockEntry(_id, getSubarchitectureID());
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        public void lockEntry(String _id, WorkingMemoryPermissions _permissions)
                        throws DoesNotExistOnWMException {
                try {
                        lockEntry(_id, getSubarchitectureID(), _permissions);
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        public void tryLockEntry(String _id, WorkingMemoryPermissions _permissions)
                        throws DoesNotExistOnWMException {
                try {
                        lockEntry(_id, getSubarchitectureID(), _permissions);
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        //

        public boolean isOverwritable(String _id) throws WMException {
                if (holdsOverwriteLock(_id)) {
                        return true;
                } else {
                        WorkingMemoryPermissions permissions = getPermissions(_id);
                        return CASTUtils.overwriteAllowed(permissions);
                }
        }

        public boolean isDeletable(String _id) throws WMException {
                if (holdsDeleteLock(_id)) {
                        return true;
                } else {
                        WorkingMemoryPermissions permissions = getPermissions(_id);
                        return CASTUtils.deleteAllowed(permissions);
                }
        }

        public boolean isReadable(String _id) throws WMException {
                if (holdsReadLock(_id)) {
                        return true;
                } else {
                        WorkingMemoryPermissions permissions = getPermissions(_id);
                        return CASTUtils.readAllowed(permissions);
                }
        }

        public WorkingMemoryPermissions getPermissions(String _id)
                        throws WMException {
                try {
                        return getPermissions(_id, getSubarchitectureID());
                } catch (UnknownSubarchitectureException e) {
                        throw new RuntimeException(
                                        "Shouldn't happen on own subarchitecture", e);
                }
        }

        public boolean holdsLock(String _id) {
                return holdsOverwriteLock(_id);
        }

        public boolean holdsLock(String _id, String _subarch) {
                return holdsOverwriteLock(_id, _subarch);
        }

        public boolean holdsOverwriteLock(String _id) {
                // any lock is an overwrite lock
                return m_permissions.getPermissions(_id) != null;
        }

        public boolean holdsDeleteLock(String _id) {
                WorkingMemoryPermissions permissions = m_permissions
                                .getPermissions(_id);
                return permissions != null
                                && (permissions == WorkingMemoryPermissions.LOCKEDOD || permissions == WorkingMemoryPermissions.LOCKEDODR);
        }

        public boolean holdsReadLock(String _id) {
                WorkingMemoryPermissions permissions = m_permissions
                                .getPermissions(_id);
                return permissions != null
                                && permissions == WorkingMemoryPermissions.LOCKEDODR;
        }

        public boolean holdsOverwriteLock(String _id, String _subarch) {
                // any lock is an overwrite lock
                return m_permissions.getPermissions(_id, _subarch) != null;
        }

        public boolean holdsDeleteLock(String _id, String _subarch) {
                WorkingMemoryPermissions permissions = m_permissions.getPermissions(
                                _id, _subarch);
                return permissions != null
                                && (permissions == WorkingMemoryPermissions.LOCKEDOD || permissions == WorkingMemoryPermissions.LOCKEDODR);
        }

        public boolean holdsReadLock(String _id, String _subarch) {
                WorkingMemoryPermissions permissions = m_permissions.getPermissions(
                                _id, _subarch);
                return permissions != null
                                && permissions == WorkingMemoryPermissions.LOCKEDODR;
        }

        protected boolean needsConsistencyCheck(String _id) {
                return m_permissions.needsConsistencyCheck(_id);
        }

        protected boolean needsConsistencyCheck(String _id, String _subarch) {
                return m_permissions.needsConsistencyCheck(_id, _subarch);
        }

        protected void consistencyChecked(String _id) {
                m_permissions.consistencyChecked(_id);
        }

        protected void consistencyChecked(String _id, String _subarch) {
                m_permissions.consistencyChecked(_id, _subarch);
        }

}

---