@Override
public void chunkEncoded(ChunkEvent ce) {
/*
* add that first reference time
*/
ce.getSource().getSubsymbolicChunk().accessed(ce.getSimulationTime());
}
/**
* handles the updating of associative links, references times, and context/needed tallies. should
* also handle similarities, but that is not implemented yet and will be by the six version of
* this.<br>
* The updating is done here since the listener is removed after encoding, so the master chunk
* will not have this listener attached
*
* @param event
* @see
* org.jactr.core.chunk.event.ChunkListenerAdaptor#mergingInto(org.jactr.core.chunk.event.ChunkEvent)
*/
@Override
public void mergingInto(ChunkEvent event) {
IChunk self = event.getSource();
IChunk master = event.getChunk();
ISubsymbolicChunk4 selfSSC = (ISubsymbolicChunk4) self.getSubsymbolicChunk();
ISubsymbolicChunk4 masterSSC = (ISubsymbolicChunk4) master.getSubsymbolicChunk();
// update the references for master
masterSSC.accessed(event.getSimulationTime());
masterSSC.setTimesInContext(masterSSC.getTimesInContext() + selfSSC.getTimesInContext());
masterSSC.setTimesNeeded(masterSSC.getTimesNeeded() + selfSSC.getTimesNeeded());
/*
* and refs
*/
IReferences refs = masterSSC.getReferences();
for (double refTime : selfSSC.getReferences().getTimes()) refs.addReferenceTime(refTime);
// will allocate
Collection<Link> links = selfSSC.getIAssociations(null);
for (Link iLink : links) {
IChunk iChunk = iLink.getIChunk();
Link masterLink = masterSSC.getIAssociation(iChunk);
if (masterLink != null) {
/** need to merge the links */
if (LOGGER.isDebugEnabled())
LOGGER.debug(master + " already linked to " + iChunk + ", merging");
masterLink.setCount(Math.max(masterLink.getCount(), iLink.getCount()));
masterLink.setStrength(Math.max(masterLink.getStrength(), iLink.getStrength()));
} else {
/** add the link to master */
if (LOGGER.isDebugEnabled())
LOGGER.debug(master + " not already linked to " + iChunk + ", linking.");
Link newLink = new Link(master, iChunk, iLink.getCount(), iLink.getStrength());
masterSSC.addLink(newLink);
((ISubsymbolicChunk4) iChunk.getSubsymbolicChunk()).addLink(newLink);
}
/*
* reduce the count so that we are sure we're removing the link
*/
iLink.setCount(1);
selfSSC.removeLink(iLink);
((ISubsymbolicChunk4) iChunk.getSubsymbolicChunk()).removeLink(iLink);
}
links.clear();
links = selfSSC.getJAssociations(links);
for (Link jLink : links) {
IChunk jChunk = jLink.getJChunk();
Link masterLink = masterSSC.getIAssociation(jChunk);
if (masterLink != null) {
/** need to merge the links */
if (LOGGER.isDebugEnabled())
LOGGER.debug(jChunk + " already linked to " + master + ", merging");
masterLink.setCount(Math.max(masterLink.getCount(), jLink.getCount()));
masterLink.setStrength(Math.max(masterLink.getStrength(), jLink.getStrength()));
} else {
/** add the link to master */
if (LOGGER.isDebugEnabled())
LOGGER.debug(jChunk + " not already linked to " + master + ", linking.");
Link newLink = new Link(jChunk, master, jLink.getCount(), jLink.getStrength());
masterSSC.addLink(newLink);
((ISubsymbolicChunk4) jChunk.getSubsymbolicChunk()).addLink(newLink);
}
/*
* reduce the count so that we are sure we're removing the link
*/
jLink.setCount(1);
selfSSC.removeLink(jLink);
((ISubsymbolicChunk4) jChunk.getSubsymbolicChunk()).removeLink(jLink);
}
}
@Override
public void slotChanged(ChunkEvent ce) {
IChunk iChunk = ce.getSource();
Object oldValue = ce.getOldSlotValue();
Object newValue = ce.getNewSlotValue();
if (LOGGER.isDebugEnabled())
LOGGER.debug(iChunk + "." + ce.getSlotName() + "=" + newValue + " (was " + oldValue + ")");
/*
* we can only do this if ISubsymbolicChunk is ISubsymbolicChunk4
*/
if (!(iChunk.getSubsymbolicChunk() instanceof ISubsymbolicChunk4)) {
if (LOGGER.isWarnEnabled())
LOGGER.warn(
"Can only adjust associative links if the chunk's subsymbolic is derived from ISubsymbolicChunk4");
return;
}
/*
* I chunk is the owner that references J
*/
ISubsymbolicChunk4 sscI = (ISubsymbolicChunk4) iChunk.getSubsymbolicChunk();
/*
* first the old chunk value..
*/
if (oldValue instanceof IChunk) {
IChunk jChunk = (IChunk) oldValue;
if (jChunk.getSubsymbolicChunk() instanceof ISubsymbolicChunk4) {
ISubsymbolicChunk4 sscJ = (ISubsymbolicChunk4) jChunk.getSubsymbolicChunk();
Link sJI = sscJ.getIAssociation(iChunk);
if (sJI != null) {
sJI.decrement();
if (sJI.getCount() == 0) {
if (LOGGER.isDebugEnabled())
LOGGER.debug("Removing link between " + iChunk + " and " + jChunk + " : " + sJI);
sscI.removeLink(sJI);
sscJ.removeLink(sJI);
} else if (LOGGER.isDebugEnabled())
LOGGER.debug(
"Multiple links established between "
+ iChunk
+ " and "
+ jChunk
+ " decrementing : "
+ sJI);
}
} else if (LOGGER.isWarnEnabled())
LOGGER.warn(
"old value " + jChunk + " doesn't have a ISubsymbolicChunk4, nothing to be done");
}
/*
* now for the new one
*/
if (newValue instanceof IChunk) {
IChunk jChunk = (IChunk) newValue;
if (jChunk.getSubsymbolicChunk() instanceof ISubsymbolicChunk4) {
ISubsymbolicChunk4 sscJ = (ISubsymbolicChunk4) jChunk.getSubsymbolicChunk();
Link sJI = sscJ.getIAssociation(iChunk);
/*
* is this a new linkage?
*/
if (sJI == null) {
sJI = new Link(jChunk, iChunk);
if (LOGGER.isDebugEnabled())
LOGGER.debug("Adding link between " + iChunk + " and " + jChunk + " : " + sJI);
sscI.addLink(sJI);
sscJ.addLink(sJI);
} else {
sJI.increment(); // not new, but we need to increment the link
if (LOGGER.isDebugEnabled())
LOGGER.debug(
"Link already established between "
+ iChunk
+ " and "
+ jChunk
+ " incrementing : "
+ sJI);
}
} else if (LOGGER.isWarnEnabled())
LOGGER.warn(
"new value " + jChunk + " doesn't have a ISubsymbolicChunk4, nothing to be done");
}
}