org.ggp.base.util.statemachine.cache.CachedStateMachine Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alloy-ggp-base Show documentation
A modified version of the GGP-Base library for Alloy.
The newest version!
package org.ggp.base.util.statemachine.cache;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.ggp.base.util.gdl.grammar.Gdl;
import org.ggp.base.util.propnet.architecture.Component;
import org.ggp.base.util.propnet.architecture.PropNet;
import org.ggp.base.util.statemachine.MachineState;
import org.ggp.base.util.statemachine.Move;
import org.ggp.base.util.statemachine.Role;
import org.ggp.base.util.statemachine.StateMachine;
import org.ggp.base.util.statemachine.exceptions.GoalDefinitionException;
import org.ggp.base.util.statemachine.exceptions.MoveDefinitionException;
import org.ggp.base.util.statemachine.exceptions.TransitionDefinitionException;

import com.google.common.collect.ImmutableList;

public final class CachedStateMachine extends StateMachine
{
    private final StateMachine backingStateMachine;
    private final TtlCache ttlCache;

    private final class Entry
    {
        public Map goals;
        public Map> moves;
        public Map, MachineState> nexts;
        public Boolean terminal;

        public Entry()
        {
            goals = new HashMap();
            moves = new HashMap>();
            nexts = new HashMap, MachineState>();
            terminal = null;
        }
    }

    public CachedStateMachine(StateMachine backingStateMachine)
    {
        this.backingStateMachine = backingStateMachine;
        ttlCache = new TtlCache(1);
    }

    private Entry getEntry(MachineState state)
    {
        if (!ttlCache.containsKey(state))
        {
            ttlCache.put(state, new Entry());
        }

        return ttlCache.get(state);
    }

    @Override
    public int getGoal(MachineState state, Role role) throws GoalDefinitionException
    {
        Entry entry = getEntry(state);
        synchronized (entry)
        {
            if (!entry.goals.containsKey(role))
            {
                entry.goals.put(role, backingStateMachine.getGoal(state, role));
            }

            return entry.goals.get(role);
        }
    }

    @Override
    public List getLegalMoves(MachineState state, Role role) throws MoveDefinitionException
    {
        Entry entry = getEntry(state);
        synchronized (entry)
        {
            if (!entry.moves.containsKey(role))
            {
                entry.moves.put(role, ImmutableList.copyOf(backingStateMachine.getLegalMoves(state, role)));
            }

            return entry.moves.get(role);
        }
    }

    @Override
    public MachineState getNextState(MachineState state, List moves) throws TransitionDefinitionException
    {
        Entry entry = getEntry(state);
        synchronized (entry)
        {
            if (!entry.nexts.containsKey(moves))
            {
                entry.nexts.put(moves, backingStateMachine.getNextState(state, moves));
            }

            return entry.nexts.get(moves);
        }
    }

    @Override
    public boolean isTerminal(MachineState state)
    {
        Entry entry = getEntry(state);
        synchronized (entry)
        {
            if (entry.terminal == null)
            {
                entry.terminal = backingStateMachine.isTerminal(state);
            }

            return entry.terminal;
        }
    }

    @Override
    public void doPerMoveWork()
    {
        prune();
    }

    public void prune()
    {
        ttlCache.prune();
    }

    @Override
    public void initialize(List description) {
        backingStateMachine.initialize(description);
    }

    @Override
    public List getRoles() {
        // TODO(schreib): Should this be cached as well?
        return backingStateMachine.getRoles();
    }

    @Override
    public MachineState getInitialState() {
        // TODO(schreib): Should this be cached as well?
        return backingStateMachine.getInitialState();
    }

    @Override
    public StateMachine getSynchronizedCopy() {
        // TODO: If actually using this SM, make sure to share the cache
        return new CachedStateMachine(backingStateMachine.getSynchronizedCopy());
    }

    @Override
    public Map getGebMoves(MachineState state) {
        return backingStateMachine.getGebMoves(state);
    }

    @Override
    public MachineState translateState(MachineState state) {
        return backingStateMachine.translateState(state);
    }

    @Override
    public boolean isNative(MachineState state) {
        return backingStateMachine.isNative(state);
    }

    @Override
    public boolean isPropNetBased() {
        return backingStateMachine.isPropNetBased();
    }

    @Override
    public PropNet getPropNet() {
        return backingStateMachine.getPropNet();
    }

    @Override
    public boolean getComponentValue(MachineState state, Component component) {
        return backingStateMachine.getComponentValue(state, component);
    }

    @Override
    public int getComponentTrueInputsCount(MachineState state,
            Component component) {
        return backingStateMachine.getComponentTrueInputsCount(state, component);
    }
}