org.kahina.core

Class KahinaInstance<S extends KahinaState,G extends KahinaGUI,B extends KahinaBridge,P extends KahinaProject>

java.lang.Object

org.kahina.core.KahinaInstance<S,G,B,P>

All Implemented Interfaces:

KahinaListener

Direct Known Subclasses:

FreeMUCInstance, KahinaDefaultInstance, LogicProgrammingInstance, MUCInstance, MUCInstance, TulipaInstance

public abstract class KahinaInstance<S extends KahinaState,G extends KahinaGUI,B extends KahinaBridge,P extends KahinaProject>
extends java.lang.Object
implements KahinaListener

Field Summary

Fields

Modifier and Type	Field and Description
protected B	bridge
java.util.List<KahinaPerspective>	defaultPerspectives
java.util.List<P>	defaultProjects
protected G	gui
protected KahinaController	instanceControl GUI and views listen to this controller.
protected KahinaLogger	logger
protected P	project
java.util.List<KahinaPerspective>	recentPerspectives
java.util.List<P>	recentProjects
protected KahinaController	sessionControl Everything else (e.g.
protected S	state
protected ObjectMagazine<KahinaStep>	steps
protected static boolean	VERBOSE

Constructor Summary

Constructors

Constructor and Description
KahinaInstance()

Method Summary

Methods

Modifier and Type	Method and Description
protected abstract B	createBridge()
protected abstract G	createGUI()
protected abstract P	createNewProject()
protected abstract S	createState()
protected abstract void	createTreeBehavior()
void	deregisterInstanceListener(java.lang.String type, KahinaListener listener)
void	deregisterSessionListener(java.lang.String type, KahinaListener listener)
void	dispatchEvent(KahinaEvent e)
void	dispatchInstanceEvent(KahinaEvent e)
void	dispatchSessionEvent(KahinaEvent e)
protected void	fillViewRegistry() overwrite this to register views for user-defined datatypes MUST register views for all data types use super.fillViewRegistry() in implementations to register most basic views
java.lang.String	getApplicationName()
KahinaBridge	getBridge()
G	getGUI()
KahinaLogger	getLogger()
P	getProject()
KahinaProjectStatus	getProjectStatus()
S	getState()
protected void	initializeNewSession(boolean withBridge)
protected KahinaPerspective	loadPerspective(java.io.InputStream stream)
abstract P	loadProject(java.io.File file)
void	newProject(java.io.File grammarFile, java.lang.String name)
protected abstract void	preparePerspectiveLists()
protected abstract void	prepareProjectLists()
void	processEvent(KahinaEvent e)
protected void	processNewProject()
protected void	processProjectEvent(KahinaProjectEvent e)
void	registerInstanceListener(java.lang.String type, KahinaListener listener)
protected void	registerRecentPerspective(KahinaPerspective psp)
protected void	registerRecentProject(P prj)
void	registerSessionListener(java.lang.String type, KahinaListener listener)
void	saveProjectAs(java.io.File projectFile)
void	setProjectStatus(KahinaProjectStatus projectStatus)
void	start(java.lang.String[] args) Writing a main method for a Kahina-based debugging environment is simple: just create an instance of your KahinaInstance subclass and pass its start method the arguments.
B	startNewSession()
void	startNewSessionWithoutBridge()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

VERBOSE

protected static final boolean VERBOSE

See Also:

Constant Field Values

gui

protected G extends KahinaGUI gui

state

protected S extends KahinaState state

bridge

protected B extends KahinaBridge bridge

project

protected P extends KahinaProject project

recentPerspectives

public java.util.List<KahinaPerspective> recentPerspectives

defaultPerspectives

public java.util.List<KahinaPerspective> defaultPerspectives

recentProjects

public java.util.List<P extends KahinaProject> recentProjects

defaultProjects

public java.util.List<P extends KahinaProject> defaultProjects

steps

protected ObjectMagazine<KahinaStep> steps

instanceControl

protected final KahinaController instanceControl

GUI and views listen to this controller. It never changes.

sessionControl

protected KahinaController sessionControl

Everything else (e.g. bridges) listens to this controller. It changes with every session.

logger

protected KahinaLogger logger

Constructor Detail

KahinaInstance

public KahinaInstance()

Method Detail

preparePerspectiveLists

protected abstract void preparePerspectiveLists()

prepareProjectLists

protected abstract void prepareProjectLists()

startNewSessionWithoutBridge

public void startNewSessionWithoutBridge()

startNewSession

public B startNewSession()

initializeNewSession

protected void initializeNewSession(boolean withBridge)

registerSessionListener

public void registerSessionListener(java.lang.String type,
                           KahinaListener listener)

registerInstanceListener

public void registerInstanceListener(java.lang.String type,
                            KahinaListener listener)

deregisterSessionListener

public void deregisterSessionListener(java.lang.String type,
                             KahinaListener listener)

deregisterInstanceListener

public void deregisterInstanceListener(java.lang.String type,
                              KahinaListener listener)

createTreeBehavior

protected abstract void createTreeBehavior()

createState

protected abstract S createState()

createGUI

protected abstract G createGUI()

createBridge

protected abstract B createBridge()

createNewProject

protected abstract P createNewProject()

getState

public S getState()

setProjectStatus

public void setProjectStatus(KahinaProjectStatus projectStatus)

getProjectStatus

public KahinaProjectStatus getProjectStatus()

fillViewRegistry

protected void fillViewRegistry()

overwrite this to register views for user-defined datatypes MUST register views for all data types use super.fillViewRegistry() in implementations to register most basic views

dispatchEvent

public void dispatchEvent(KahinaEvent e)

dispatchSessionEvent

public void dispatchSessionEvent(KahinaEvent e)

dispatchInstanceEvent

public void dispatchInstanceEvent(KahinaEvent e)

processEvent

public void processEvent(KahinaEvent e)

Specified by:

processEvent in interface KahinaListener

processProjectEvent

protected void processProjectEvent(KahinaProjectEvent e)

processNewProject

protected void processNewProject()

loadPerspective

protected KahinaPerspective loadPerspective(java.io.InputStream stream)

registerRecentPerspective

protected void registerRecentPerspective(KahinaPerspective psp)

registerRecentProject

protected void registerRecentProject(P prj)

start

public void start(java.lang.String[] args)

Writing a main method for a Kahina-based debugging environment is simple: just create an instance of your KahinaInstance subclass and pass its start method the arguments.

Parameters:

args -

getBridge

public KahinaBridge getBridge()

getApplicationName

public java.lang.String getApplicationName()

getProject

public P getProject()

getLogger

public KahinaLogger getLogger()

newProject

public void newProject(java.io.File grammarFile,
              java.lang.String name)

saveProjectAs

public void saveProjectAs(java.io.File projectFile)

loadProject

public abstract P loadProject(java.io.File file)

getGUI

public G getGUI()