package com.plectix.simulator.staticanalysis.stories.storage;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import com.plectix.simulator.staticanalysis.stories.ActionOfAEvent;
import com.plectix.simulator.staticanalysis.stories.TypeOfWire;
public class MasterInformationAboutWires {
private LinkedHashMap<WireHashKey, LinkedHashSet<String>> internalStatesByWire;
private LinkedHashMap<WireHashKey, LinkedHashSet<StateOfLink>> linkStatesByWire;
private LinkedHashMap<WireHashKey, Integer> numberOfUnresolvedEventOnWire;
public MasterInformationAboutWires(
LinkedHashMap<WireHashKey, LinkedHashSet<String>> internalStatesByWire,
LinkedHashMap<WireHashKey, LinkedHashSet<StateOfLink>> linkStatesByWire,
LinkedHashMap<WireHashKey, Integer> numberOfUnresolvedEventOnWire) {
this.internalStatesByWire = internalStatesByWire;
this.linkStatesByWire = linkStatesByWire;
this.numberOfUnresolvedEventOnWire = numberOfUnresolvedEventOnWire;
}
public LinkedHashMap<WireHashKey, LinkedHashSet<String>> getInternalStatesByWire() {
return internalStatesByWire;
}
public void setInternalStatesByWire(
LinkedHashMap<WireHashKey, LinkedHashSet<String>> internalStatesByWire) {
this.internalStatesByWire = internalStatesByWire;
}
public LinkedHashMap<WireHashKey, LinkedHashSet<StateOfLink>> getLinkStatesByWire() {
return linkStatesByWire;
}
public void setLinkStatesByWire(
LinkedHashMap<WireHashKey, LinkedHashSet<StateOfLink>> linkStatesByWire) {
this.linkStatesByWire = linkStatesByWire;
}
public LinkedHashMap<WireHashKey, Integer> getNumberOfUnresolvedEventOnWire() {
return numberOfUnresolvedEventOnWire;
}
public void setNumberOfUnresolvedEventOnWire(
LinkedHashMap<WireHashKey, Integer> numberOfUnresolvedEventOnWire) {
this.numberOfUnresolvedEventOnWire = numberOfUnresolvedEventOnWire;
}
void fullInformationAboutWires(AtomicEvent<?> atomicEvent,
WireHashKey key) throws StoryStorageException {
ActionOfAEvent type = atomicEvent.getType();
AbstractState<?> state = atomicEvent.getState();
if (key.getTypeOfWire() == TypeOfWire.INTERNAL_STATE) {
if (internalStatesByWire.get(key) == null) {
LinkedHashSet<String> internalStates = new LinkedHashSet<String>();
internalStatesByWire.put(key, internalStates);
}
if (type == ActionOfAEvent.TEST_AND_MODIFICATION) {
internalStatesByWire.get(key).add(
(String) (state.getAfterState()));
internalStatesByWire.get(key).add(
(String) (state.getBeforeState()));
}
if (atomicEvent.getType() == ActionOfAEvent.MODIFICATION) {
internalStatesByWire.get(key).add(
(String) (state.getAfterState()));
}
} else if (key.getTypeOfWire() == TypeOfWire.LINK_STATE) {
if (linkStatesByWire.get(key) == null) {
LinkedHashSet<StateOfLink> linkStates = new LinkedHashSet<StateOfLink>();
linkStatesByWire.put(key, linkStates);
}
switch (type) {
case TEST_AND_MODIFICATION:
StateOfLink before = (StateOfLink) (state.getBeforeState());
if (before != null && !before.isFree())
linkStatesByWire.get(key).add(before);
case MODIFICATION:
StateOfLink after = (StateOfLink) (state.getAfterState());
if (after != null && !after.isFree())
linkStatesByWire.get(key).add(after);
break;
}
}
}
public void updateWires(Set<WireHashKey> wires,
Map<WireHashKey, TreeMap<Long, AtomicEvent<?>>> map)
throws StoryStorageException {
for (WireHashKey wk : wires) {
LinkedHashSet<String> linkedHashSet = internalStatesByWire.get(wk);
if (linkedHashSet != null) {
linkedHashSet.clear();
}
LinkedHashSet<StateOfLink> linkedHashSet2 = linkStatesByWire
.get(wk);
if (linkedHashSet2 != null) {
linkedHashSet2.clear();
}
if (map == null) {
throw new StoryStorageException("empty map");
}
if (map.get(wk) == null) {
throw new StoryStorageException("miss wire");
}
for (AtomicEvent<?> atomicEvent : map.get(wk).values()) {
fullInformationAboutWires(atomicEvent, wk);
}
}
}
public boolean tryToSwapLink(long agentId, Map<Long, AtomicEvent<?>> wire) {
for (AtomicEvent<?> ae : wire.values()) {
if (ae.getState().getAfterState() != null) {
if (((StateOfLink) (ae.getState().getAfterState()))
.getAgentId() == agentId)
return false;
}
if (ae.getState().getBeforeState() != null) {
if (((StateOfLink) (ae.getState().getBeforeState()))
.getAgentId() == agentId)
return false;
}
}
return true;
}
public final int getUnresolvedModifyCount(WireHashKey wkey)
throws StoryStorageException {
if (wkey == null || getNumberOfUnresolvedEventOnWire() == null
|| getNumberOfUnresolvedEventOnWire().get(wkey) == null) {
throw new StoryStorageException("wire = null");
}
return getNumberOfUnresolvedEventOnWire().get(wkey);
}
public final void upNumberOfUnresolvedModifyEvent(WireHashKey wireKey,
boolean up) throws StoryStorageException {
int x = getUnresolvedModifyCount(wireKey);
if (up) {
x++;
} else {
x--;
}
if (x < 0)
throw new StoryStorageException(
"negative number of unresolved events on wire");
putUnresolvedModifyEvent(wireKey, Integer.valueOf(x));
}
public final void putUnresolvedModifyEvent(WireHashKey wireHashKey,
int valueOf) {
getNumberOfUnresolvedEventOnWire().put(wireHashKey, valueOf);
}
public final Iterator<String> wireInternalStateIterator(WireHashKey wkey)
throws StoryStorageException {
if (wkey.getTypeOfWire() == TypeOfWire.INTERNAL_STATE) {
if (getInternalStatesByWire().get(wkey) == null) {
throw new StoryStorageException("empty internal states ^(");
}
return getInternalStatesByWire().get(wkey).iterator();
} else {
throw new StoryStorageException(
"wireInternalStateIterator : prohibit type of wire");
}
}
public final Iterator<StateOfLink> wireLinkStateIterator(WireHashKey wkey)
throws StoryStorageException {
if (wkey.getTypeOfWire() == TypeOfWire.LINK_STATE) {
if (getLinkStatesByWire().get(wkey) == null) {
throw new StoryStorageException("empty link states ^(");
}
return getLinkStatesByWire().get(wkey).iterator();
} else {
throw new StoryStorageException(
"wireLinkStateIterator : prohibit type of wire");
}
}
public void removeWire(WireHashKey wk) {
internalStatesByWire.remove(wk);
linkStatesByWire.remove(wk);
numberOfUnresolvedEventOnWire.remove(wk);
}
}