Package org.jetbrains.mps.openapi.module

Class SRepositoryContentAdapter

java.lang.Object

org.jetbrains.mps.openapi.module.SModuleListenerBase

org.jetbrains.mps.openapi.module.SRepositoryContentAdapter

All Implemented Interfaces:

SModelListener, SNodeAccessListener, SNodeChangeListener, SModuleListener, SRepositoryAttachListener, SRepositoryListener

public class SRepositoryContentAdapter
extends SModuleListenerBase
implements SModelListener, SModuleListener, SRepositoryListener, SRepositoryAttachListener, SNodeChangeListener, SNodeAccessListener

This class serves as a convenient implementation of all repository listeners at once. In addition it tracks all objects (modules, models and nodes) as they come and leave the repository.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	SRepositoryContentAdapter()

Method Summary

Modifier and Type	Method	Description
void	beforeModelRemoved(SModule module, SModel model)
void	beforeModuleRemoved(SModule module)
void	commandFinished(SRepository repository)
void	commandStarted(SRepository repository)	Notifications about commands in a ModelAccess associated with the repository.
void	conflictDetected(SModel model)	This event is fired when the storage-memory conflict is detected (== isChanged() && needsReloading()).
protected boolean	isIncluded(SModule module)
void	modelAdded(SModule module, SModel model)
void	modelAttached(SModel model, SRepository repository)	Fired when a model becomes visible in a repository.
void	modelDetached(SModel model, SRepository repository)	Fired when a model is no longer part of a repository, e.g.
void	modelLoaded(SModel model, boolean partially)
void	modelRemoved(SModule module, SModelReference ref)	Model is removed from a repository.
void	modelReplaced(SModel model)
void	modelSaved(SModel model)
void	modelUnloaded(SModel model)
void	moduleAdded(SModule module)
void	moduleChanged(SModule module)	Any change including module dependencies and descriptor reload from disk
void	moduleRemoved(SModuleReference module)
void	nodeAdded(SNodeAddEvent event)
void	nodeRead(SNodeReadEvent event)
void	nodeRemoved(SNodeRemoveEvent event)
void	problemsDetected(SModel model, Iterable<SModel.Problem> problems)	This method is called each time a new problem, or a set of problems is discovered.
void	propertyChanged(SPropertyChangeEvent event)
void	propertyRead(SPropertyReadEvent event)
void	referenceChanged(SReferenceChangeEvent event)
void	referenceRead(SReferenceReadEvent event)
void	repositoryChanged()	Handy notification about change in repository structure, namely added/removed modules and models.
void	repositoryCommandFinished(SRepository repository)
void	repositoryCommandStarted(SRepository repository)
protected void	startListening(SModel model)	no-op by default.
protected void	startListening(SModule module)
void	startListening(SRepository repository)
protected void	stopListening(SModel model)	no-op by default
protected void	stopListening(SModule module)
void	stopListening(SRepository repository)
void	subscribeTo(SRepository repository)
void	unsubscribeFrom(SRepository repository)
void	updateFinished(SRepository repository)
void	updateStarted(SRepository repository)

Methods inherited from class org.jetbrains.mps.openapi.module.SModuleListenerBase

beforeModelRenamed, dependencyAdded, dependencyRemoved, languageAdded, languageRemoved, modelRenamed, moduleRenamed

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.jetbrains.mps.openapi.module.SModuleListener

beforeModelRenamed, dependencyAdded, dependencyRemoved, languageAdded, languageRemoved, modelRenamed

Constructor Detail

SRepositoryContentAdapter

protected SRepositoryContentAdapter()

Method Detail

subscribeTo

public void subscribeTo(SRepository repository)

unsubscribeFrom

public void unsubscribeFrom(SRepository repository)

startListening

public void startListening(@NotNull
                           SRepository repository)

Specified by:

startListening in interface SRepositoryAttachListener

stopListening

public void stopListening(@NotNull
                          SRepository repository)

Specified by:

stopListening in interface SRepositoryAttachListener

startListening

protected void startListening(SModule module)

stopListening

protected void stopListening(SModule module)

startListening

protected void startListening(@NotNull
                              SModel model)

no-op by default. Subclasses that wish to get model/node change/access events, shall add appropriate listeners here. These listeners are implemented by this class only for convenience, events are not dispatched unless proper listener is explicitly attached.

stopListening

protected void stopListening(@NotNull
                             SModel model)

no-op by default

isIncluded

protected boolean isIncluded(SModule module)

Returns:

always true

moduleAdded

public void moduleAdded(@NotNull
                        SModule module)

Specified by:

moduleAdded in interface SRepositoryListener

beforeModuleRemoved

public void beforeModuleRemoved(@NotNull
                                SModule module)

Specified by:

beforeModuleRemoved in interface SRepositoryListener

moduleRemoved

public void moduleRemoved(@NotNull
                          SModuleReference module)

Specified by:

moduleRemoved in interface SRepositoryListener

commandStarted

public void commandStarted(SRepository repository)

Description copied from interface: SRepositoryListener

Notifications about commands in a ModelAccess associated with the repository. It's convenient to have command notifications right in SRepositoryListener implementation, like RepositoryChangeTracker (the one where all changes within a command are collected), rather than have distinct CommandListener. Unlike CommandListener, gives context repository to facilitate use of the same listener instance among different repositories.

Specified by:

commandStarted in interface SRepositoryListener

See Also:

CommandListener.commandStarted()

commandFinished

public void commandFinished(SRepository repository)

Specified by:

commandFinished in interface SRepositoryListener

See Also:

CommandListener.commandFinished()

updateStarted

public void updateStarted(SRepository repository)

Specified by:

updateStarted in interface SRepositoryListener

updateFinished

public void updateFinished(SRepository repository)

Specified by:

updateFinished in interface SRepositoryListener

repositoryCommandStarted

public void repositoryCommandStarted(SRepository repository)

Specified by:

repositoryCommandStarted in interface SRepositoryListener

repositoryCommandFinished

public void repositoryCommandFinished(SRepository repository)

Specified by:

repositoryCommandFinished in interface SRepositoryListener

moduleChanged

public void moduleChanged(SModule module)

Description copied from interface: SModuleListener

Any change including module dependencies and descriptor reload from disk

Specified by:

moduleChanged in interface SModuleListener

Overrides:

moduleChanged in class SModuleListenerBase

modelAdded

public void modelAdded(SModule module,
                       SModel model)

Specified by:

modelAdded in interface SModuleListener

Overrides:

modelAdded in class SModuleListenerBase

beforeModelRemoved

public void beforeModelRemoved(SModule module,
                               SModel model)

Specified by:

beforeModelRemoved in interface SModuleListener

Overrides:

beforeModelRemoved in class SModuleListenerBase

modelRemoved

public void modelRemoved(SModule module,
                         SModelReference ref)

Description copied from interface: SModuleListener

Model is removed from a repository. Note, it doesn't necessarily mean model was deleted. Does NOT come for module's models when module is being un-registered from a repository

Specified by:

modelRemoved in interface SModuleListener

Overrides:

modelRemoved in class SModuleListenerBase

modelLoaded

public void modelLoaded(SModel model,
                        boolean partially)

Specified by:

modelLoaded in interface SModelListener

modelReplaced

public void modelReplaced(SModel model)

Specified by:

modelReplaced in interface SModelListener

modelUnloaded

public void modelUnloaded(SModel model)

Specified by:

modelUnloaded in interface SModelListener

modelSaved

public void modelSaved(SModel model)

Specified by:

modelSaved in interface SModelListener

conflictDetected

public void conflictDetected(SModel model)

Description copied from interface: SModelListener

This event is fired when the storage-memory conflict is detected (== isChanged() && needsReloading()).

Specified by:

conflictDetected in interface SModelListener

problemsDetected

public void problemsDetected(SModel model,
                             Iterable<SModel.Problem> problems)

Description copied from interface: SModelListener

This method is called each time a new problem, or a set of problems is discovered.

Specified by:

problemsDetected in interface SModelListener

modelAttached

public void modelAttached(SModel model,
                          SRepository repository)

Description copied from interface: SModelListener

Fired when a model becomes visible in a repository.

IMPORTANT: it's unspecified whether the model is part of a module the moment this event is fired or not. Do not expect SModel.getModule() to give meaningful value. This contract may change (i.e. become stricter) in future.

NOTE: This is not an event most clients could make use of, as it's technically tricky to attach a listener to a model not yet visible inside a repository, and thus it's more of internal mechanism (i.e. code that instantiates a model may attach a listener to not yet published model and thus get notified). Besides, detached models do not get their listeners automatically discarded, and the listeners get a chance to react to model detach/re-attach sequence with this event.

Specified by:

modelAttached in interface SModelListener

Parameters:

model - affected model, never null

repository - repository the model become available at, never null

modelDetached

public void modelDetached(SModel model,
                          SRepository repository)

Description copied from interface: SModelListener

Fired when a model is no longer part of a repository, e.g. due to removal from module. This event is intended to clean-up listener caches associated with the model and to gracefully unregister other listeners.

IMPORTANT: it's unspecified whether the model is part of a module the moment this event is fired or not. Do not expect SModel.getModule() to give meaningful value. This contract may change (i.e. become stricter) in future.

Primary drive force for this event is desire to add model listener only, without a need to listen to module events to find out when the model is no longer available.

Note, listeners not unregistered from the model would get notified with SModelListener.modelAttached(SModel, SRepository) in case detached model is brought back (perhaps, in completely different module and repository).

Specified by:

modelDetached in interface SModelListener

Parameters:

model - affected model, never null

repository - repository the model become available at, never null

repositoryChanged

public void repositoryChanged()

Handy notification about change in repository structure, namely added/removed modules and models. For unknown reason also notifies about 'unspecified' module changes no-op by default.

nodeRead

public void nodeRead(@NotNull
                     SNodeReadEvent event)

Specified by:

nodeRead in interface SNodeAccessListener

propertyRead

public void propertyRead(@NotNull
                         SPropertyReadEvent event)

Specified by:

propertyRead in interface SNodeAccessListener

referenceRead

public void referenceRead(@NotNull
                          SReferenceReadEvent event)

Specified by:

referenceRead in interface SNodeAccessListener

propertyChanged

public void propertyChanged(@NotNull
                            SPropertyChangeEvent event)

Specified by:

propertyChanged in interface SNodeChangeListener

referenceChanged

public void referenceChanged(@NotNull
                             SReferenceChangeEvent event)

Specified by:

referenceChanged in interface SNodeChangeListener

nodeAdded

public void nodeAdded(@NotNull
                      SNodeAddEvent event)

Specified by:

nodeAdded in interface SNodeChangeListener

nodeRemoved

public void nodeRemoved(@NotNull
                        SNodeRemoveEvent event)

Specified by:

nodeRemoved in interface SNodeChangeListener