org.jrebirth.af.core.ui

Class AbstractBaseController<M extends Model,V extends View<M,?,?>>

java.lang.Object

org.jrebirth.af.core.ui.AbstractBaseController<M,V>

Type Parameters:

M - the class type of the model of the view controlled

V - the class type of the view controlled

All Implemented Interfaces:

EventAdapter, Controller<M,V>

Direct Known Subclasses:

AbstractController

public abstract class AbstractBaseController<M extends Model,V extends View<M,?,?>>
extends Object
implements Controller<M,V>, EventAdapter

The abstract class AbstractBaseController. Base implementation of the controller.

Author:

Sébastien Bordes

Nested Class Summary

Nested classes/interfaces inherited from interface org.jrebirth.af.core.ui.adapter.EventAdapter

EventAdapter.Linker

Field Summary

Fields

Modifier and Type	Field and Description
private Map<EventType<? extends Event>,EventHandler<? extends Event>>	eventHandlerMap Store all event handler according to the event type.
private V	view The view component.

Constructor Summary

Constructors

Constructor and Description
AbstractBaseController(V view) Default Constructor.

Method Summary

Methods

Modifier and Type	Method and Description
void	activate() Activate the controller by initializing all event handler.
protected void	addAdapter(EventAdapter eventAdapter) Add an event adapter and automatically generate the associated event handler.
private <E extends Event> EventHandler<E>	buildEventHandler(Class<? extends EventAdapter> adapterClass, Class<? extends EventHandler<E>> handlerClass) Build an event handler by reflection using the Controller object as eventAdapter.
protected void	finalize()
protected <E extends Event> EventHandler<E>	getHandler(EventType<E> eventType) Return an EventHandler.
M	getModel()
Node	getRootNode()
V	getView()
protected abstract void	initEventAdapters() Custom method used to initialize event Adapters.
protected abstract void	initEventHandlers() Custom method used to initialize event handlers.
protected void	initInternalEventAdapters() Initialize event Adapters.
protected void	initInternalEventHandlers() Initialize event Handlers.
private boolean	isEventType(EventType<? extends Event> testEventType, EventType<? extends Event> anyEventType) Check the event type given and check the super level if necessary to always return the ANy event type.
private <E extends Event> EventHandler<E>	wrapbuildHandler(EventAdapter eventAdapter, Class<? extends EventAdapter> adapterClass, Class<? extends EventHandler<E>> handlerClass) Build an event handler by reflection to wrap the event adapter given.

Methods inherited from class java.lang.Object

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

Field Detail

view

private final transient V extends View<M,?,?> view

The view component.

eventHandlerMap

private final Map<EventType<? extends Event>,EventHandler<? extends Event>> eventHandlerMap

Store all event handler according to the event type.

Constructor Detail

AbstractBaseController

public AbstractBaseController(V view)
                       throws CoreException

Default Constructor.

Parameters:

view - the controlled view

Throws:

CoreException - if an error occurred while creating event handlers

Method Detail

activate

public final void activate()
                    throws CoreException

Activate the controller by initializing all event handler. Must be called after children initialization.

Specified by:

activate in interface Controller<M extends Model,V extends View<M,?,?>>

Throws:

CoreException - if activation fails

initInternalEventAdapters

protected final void initInternalEventAdapters()
                                        throws CoreException

Initialize event Adapters. This method is a hook to manage generic code before initializing the user event adapters. You must implement the initEventAdapters() method to prepare your controller.

Throws:

CoreException - if an error occurred while creating event adapters

initEventAdapters

protected abstract void initEventAdapters()
                                   throws CoreException

Custom method used to initialize event Adapters.

Throws:

CoreException - if an error occurred while creating event adapters

initInternalEventHandlers

protected final void initInternalEventHandlers()
                                        throws CoreException

Initialize event Handlers. This method is a hook to manage generic code before initializing the user event handlers. You must implement the initEventHandlers() method to prepare your controller.

Throws:

CoreException - if an error occurred while creating event handlers

initEventHandlers

protected abstract void initEventHandlers()
                                   throws CoreException

Custom method used to initialize event handlers.

Throws:

CoreException - if an error occurred while creating event handlers

getView

public final V getView()

Specified by:

getView in interface Controller<M extends Model,V extends View<M,?,?>>

Returns:

Returns the view.

getModel

public final M getModel()

Specified by:

getModel in interface Controller<M extends Model,V extends View<M,?,?>>

Returns:

Returns the model.

getRootNode

public final Node getRootNode()

Specified by:

getRootNode in interface Controller<M extends Model,V extends View<M,?,?>>

Returns:

Returns the root node.

addAdapter

protected final void addAdapter(EventAdapter eventAdapter)
                         throws CoreException

Add an event adapter and automatically generate the associated event handler. It could be accessed by calling getHandler(EventType)

Parameters:

eventAdapter - the EventAdapter used to route event

Throws:

CoreException - it the local api contract is not respected

getHandler

protected final <E extends Event> EventHandler<E> getHandler(EventType<E> eventType)
                                                  throws CoreException

Return an EventHandler.

Type Parameters:

E - the Event type to manage

Parameters:

eventType - the event type of the handler we want to return

Returns:

the right event handler

Throws:

CoreException - an exception if the current class doesn't implement the right EventAdapter interface.

wrapbuildHandler

private <E extends Event> EventHandler<E> wrapbuildHandler(EventAdapter eventAdapter,
                                                 Class<? extends EventAdapter> adapterClass,
                                                 Class<? extends EventHandler<E>> handlerClass)
                                                throws CoreException

Build an event handler by reflection to wrap the event adapter given.

Type Parameters:

E - the Event type to manage

Parameters:

eventAdapter - the instance of an eventAdapter

adapterClass - the adapter class used by the handler constructor

handlerClass - the handler class to build

Returns:

the required event handler

Throws:

CoreException - if an error occurred while creating the event handler

buildEventHandler

private <E extends Event> EventHandler<E> buildEventHandler(Class<? extends EventAdapter> adapterClass,
                                                  Class<? extends EventHandler<E>> handlerClass)
                                                 throws CoreException

Build an event handler by reflection using the Controller object as eventAdapter.

Type Parameters:

E - the Event type to manage

Parameters:

adapterClass - the event adapter class to used

handlerClass - the event handler class to used

Returns:

the required event handler

Throws:

CoreException - if the local api contract is not respected

isEventType

private boolean isEventType(EventType<? extends Event> testEventType,
                  EventType<? extends Event> anyEventType)

Check the event type given and check the super level if necessary to always return the ANy event type.

Parameters:

testEventType - the sub event type or any instance

anyEventType - the eventype.ANY instance

Returns:

true if the ANY event type is the same for both objects

finalize

protected void finalize()
                 throws Throwable

Overrides:

finalize in class Object

Throws:

Throwable