f.r.e.e. - Flexible Registration and Evaluation Engine: FREE::ComponentControllerBase< TControlledComponent

template<class TControlledComponent>

typedef ComponentControllerInterface::GenericComponentType FREE::ComponentControllerBase< TControlledComponent >::GenericComponentType

Generic component type

Reimplemented from FREE::ComponentControllerInterface.

Definition at line 70 of file freControllerBase.h.

template<class TControlledComponent>

typedef ComponentControllerInterface::GenericComponentPointer FREE::ComponentControllerBase< TControlledComponent >::GenericComponentPointer

Generic smartpointer for the controller interface

Reimplemented from FREE::ComponentControllerInterface.

Definition at line 72 of file freControllerBase.h.

template<class TControlledComponent>

typedef TControlledComponent FREE::ComponentControllerBase< TControlledComponent >::ComponentType

The component class managed by the controller. The component class must be a derivation from itk::LightObject to ensure the ability to use the smartpointer concept of itk

Definition at line 76 of file freControllerBase.h.

template<class TControlledComponent>

typedef ComponentType::Pointer FREE::ComponentControllerBase< TControlledComponent >::ComponentPointer

SmartPointer of the component class

Definition at line 78 of file freControllerBase.h.

template<class TControlledComponent>

typedef ComponentControllerInterface::GenericMediaType FREE::ComponentControllerBase< TControlledComponent >::GenericMediaType

Reimplemented from FREE::ComponentControllerInterface.

Definition at line 79 of file freControllerBase.h.

template<class TControlledComponent>

typedef ComponentControllerInterface::GenericMediaPointer FREE::ComponentControllerBase< TControlledComponent >::GenericMediaPointer

Reimplemented from FREE::ComponentControllerInterface.

Definition at line 80 of file freControllerBase.h.

template<class TControlledComponent>

typedef ComponentControllerInterface::AffectedElementListType FREE::ComponentControllerBase< TControlledComponent >::AffectedElementListType

Reimplemented from FREE::ComponentControllerInterface.

Definition at line 98 of file freControllerBase.h.

template<class TControlledComponent>

FREE::ComponentControllerBase< TControlledComponent >::~ComponentControllerBase ( ) [inline, virtual]

Definition at line 547 of file freControllerBase.txx.

template<class TControlledComponent>

FREE::ComponentControllerBase< TControlledComponent >::ComponentControllerBase ( ) [inline, protected]

Constructor. The constructor is defined as protected, to prevent the direct use of the class ComponentControllerBase.

Definition at line 553 of file freControllerBase.txx.

References FREE::ControllerID::ComponentControllerBase, FREE::ComponentControllerInterface::m_ControllerID, and FREE::ComponentControllerInterface::m_Description.

template<class TControlledComponent>

virtual const char* FREE::ComponentControllerBase< TControlledComponent >::GetNameOfClass ( ) const [inline, virtual]

Reimplemented from FREE::ComponentControllerInterface.

Definition at line 82 of file freControllerBase.h.

template<class TControlledComponent>

CtrlProfile::ControllerProfile::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetProfile ( const SessionComponentCache * pComponentCache ) const [inline, virtual]

Returns the controller profile for the passed component cache and regards, if needed, the current session the component is embedded in. It is possible to pass no cache, an inactive cache or the destination cache with an other component. Then the controller only regards the session and assumes that the component setup only has default values.
If you want to change the profile generation, reimplement GenerateProfile() and GenerateProfileTemplateRealization() if the profil has any templates.

Parameters:

[in] pComponentCache Pointer to the component cache that indicates the location within the session and may contain the old setup which should be regarded by the generated profile. ComponentCache may be null, but then it will only be a default profile which doesn't take any configuration of other components into account.

Returns:: Smartpointer of the generated profile.

Implements FREE::ComponentControllerInterface.

Definition at line 1007 of file freControllerBase.txx.

References FREE::ComponentControllerInterface::ControllerID(), FREE::ComponentControllerBase< TControlledComponent >::GenerateProfile(), FREE::ComponentControllerBase< TControlledComponent >::GenerateProfileTemplateRealization(), FREE::ComponentSetup::GetControllerID(), FREE::ComponentControllerInterface::m_ControllerID, FREE::ComponentControllerInterface::m_Description, FREE::ComponentControllerInterface::m_Inheritance, FREE::CtrlProfile::ControllerProfile::New(), FREE::SessionComponentCache::Setup(), and FREE::SessionComponentCache::SetupIsAssigned().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::CheckCmpActNecessityMainCmp(), FREE::ComponentControllerBase< TControlledComponent >::GetMediaControllerID(), and FREE::ComponentControllerBase< TControlledComponent >::SetParameterValue().

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::AffectedElementListType FREE::ComponentControllerBase< TControlledComponent >::GetAffectedProfileElements	(	const IDPath &	affectorID,
		SessionComponentCache *	pComponentCache,
		const ComponentSetup *	pNewAffectorSetup = `0`
	)			const `[inline, virtual]`

Returns a list with all elements of the profile of the passed component cache (target component), that may change due to the affector. It is also possible to pass a version of the affector's component setup containing the values the affector is going to have. In this case the function will check if the value change will have any effects on the.
Legal affectors are component parameters, component media links and the component itself (which would indicate that the whole (sub)component will be set/changed). It is possible to pass an inactive cache.

Parameters:

`[in]`	affectorID	IDPath of the affector. That could be a component parameter, media link or the component itself
`[in]`	pComponentCache	The cache of the target component, thus the component that should be checked for any affections.
`[in]`	pNewAffectorSetup	Pointer to a version of the affector's component setup, that contains the new values of the affector. If this parameter is null, than it is assumed that the function should check if the affector could generally has any effect on the target component. Otherwise it is assumed that it should only be checked if the value change may have any effect.

Returns:: List with global IDPathes indicating all profile elements that may by affected.

Implements FREE::ComponentControllerInterface.

Definition at line 1043 of file freControllerBase.txx.

template<class TControlledComponent>

bool FREE::ComponentControllerBase< TControlledComponent >::ControllerIsResponsible ( const GenericComponentType * pComponent ) const [inline, virtual]

Returns whether the controller is responsible for the passed component. Thus whether the type of the component is the component type of the controller.

Parameters:

[in] pComponent Pointer to the component that is supposed to be an instance of the controlled type.

Returns:: Returns true if pComponent is an instance of the controlled type; returns false if controller isn't responsible.

Implementation of FREE::ComponentControllerBase ////////////////////

Definition at line 42 of file freControllerBase.txx.

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::InitializeSetup	(	ComponentSetup *	pComponentSetup,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Initializes the ComponentSetup for the component managed by the controller. The function initializes the component setup according to its controller profile, so all parameters and subcomponents defined in the profile will be created.

Remarks:: To change or extend the automated initialisation reimplement this function.

Parameters:

`[in,out]`	pComponentSetup	Pointer to the ComponentSetup which should be initialized.
`[in]`	pComponentCache	Pointer to the component cache that indicates the location of the setup within the session and may contain the old setup which should be regarded. ComponentCache may be null, but then no configuration of components in the session will be taken into account.

dann wird bei der �bergabe aber auch noch der ComponentCache des aktuellen SessionElements ben�tigt.

Implements FREE::ComponentControllerInterface.

Definition at line 54 of file freControllerBase.txx.

template<class TControlledComponent>

SessionComponentCache::Pointer FREE::ComponentControllerBase< TControlledComponent >::BuildSetup	(	ComponentSetup *	pComponentSetup,
		SessionComponentCache *	pParentComponentCache
	)			const `[inline, virtual]`

Uses the information of the ComponentSetup to establish an object needed and specified by the setup for the registration process. Also a component cache will be created, containing a pointer to this component, the controller itself and the associated component setup.
BuildSetup creates the needed component(by BuildMainComponent()), the subcomponents (by BuildSubComponents()) and passes the component cache back.
To implement different controller behavior reimplement the methods BuildMainComponent(), BuildSubComponents() and BuildFinalization().

Parameters:

`[in]`	pComponentSetup	Pointer to the ComponentSetup, containing the whole setup information.
`[in]`	pParentComponentCache	Pointer to the parent component cache. If pointer is null, component has no parent and so is a main component.

Implements FREE::ComponentControllerInterface.

Definition at line 117 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::BuildFinalization(), FREE::ComponentControllerBase< TControlledComponent >::BuildMainComponent(), FREE::ComponentControllerBase< TControlledComponent >::BuildSubComponents(), catchAllNPassMacro, FREE::ComponentControllerInterface::ControllerID(), FREE::SessionComponentCache::New(), FREE::DirectSessionComponentAccessor::SetComponent(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

const bool FREE::ComponentControllerBase< TControlledComponent >::CheckComponentActualizationNecessity ( const SessionComponentCache * pComponentCache ) const [inline, virtual]

This function indicates, whether the component is dynamic on multiple levels (at least one parameter) and so the controller will be asked to adapt the managed component between two levels of registration. In this case the function ActualizeComponent is called, otherwise it will be ignored.

Remarks:: To change behaviour in derived classes, reimplement CheckCmpActNecessityMainCmp. By default the necessity will only be determined by the profil of the controller. If any controller parameters are dynamic on multiple resolutions, a necessity is given.

Parameters:

[in] pComponentCache Pointer to the component cache, containing setup information of the controlled component. This information may be used to determine if actualization is necessary or not.

Returns:: If the return is true, ActualizeComponent will be called and at least one parameter is dynamic.

Implements FREE::ComponentControllerInterface.

Definition at line 214 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::CheckCmpActNecessityMainCmp(), and FREE::ComponentControllerBase< TControlledComponent >::CheckCmpActNecessitySubCmp().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeComponent	(	SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo,
		const unsigned int &	iActiveLayer = `0`
	)			const `[inline, virtual]`

This function is used to actualize the component managed by the controller when the resolution level of a registration is to be changed. The function is also called - before the component is used (e.g. registration will start)

to set the parameters of the component. (This function is called even, if CheckComponentActualizationNecessity() is false.) After completing the function the component is ready to do its job.

Remarks:: This member function is only for realizing a general interface and calls ActualizeMainComponent(), ActualizeSubCompoents() and ActualizeFinalization(). Reimplement these member functions to alter the controllers behavior.

Parameters:

`[in,out]`	pComponentCache	Pointer to the component cache that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.
`[in]`	iActiveLayer	Indicates which layer of a parameter should be used if the parameter is layer sensitive (e.g. as resolution level of a registration). Default is 0.

Implements FREE::ComponentControllerInterface.

Definition at line 152 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::ActualizeFinalization(), FREE::ComponentControllerBase< TControlledComponent >::ActualizeMainComponent(), FREE::ComponentControllerBase< TControlledComponent >::ActualizeSubComponents(), catchAllNPassMacro, FREE::SessionBuilder::CheckComponentNecessity(), FREE::DirectSessionComponentAccessor::GetComponent(), FREE::SessionComponentCache::IsActive(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ResetComponent	(	SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, virtual]`

This function resets the component and all sub components to a state equal to the new building of the component. In the default implementation the setup and the cache repository stay untouched, only the the component itsself and the sub components will be renewed.

Remarks:: This member function is only for realizing a general interface and calls ResetMainComponent(), ResetSubCompoents() and ResetFinalization(). Reimplement these member functions to alter the controllers behavior.

Parameters:

`[in,out]`	pComponentCache	Pointer to the component cache, that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.

Implements FREE::ComponentControllerInterface.

Definition at line 174 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::SessionComponentCache::IsActive(), FREE::ComponentControllerBase< TControlledComponent >::ResetFinalization(), FREE::ComponentControllerBase< TControlledComponent >::ResetMainComponent(), FREE::ComponentControllerBase< TControlledComponent >::ResetSubComponents(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntry	(	StatisticEntry &	rStatisticEntry,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, virtual]`

This function is used to gather the statistically important imformation of the component. The function is also called if point in the processing is reached where the controller should gather the information.

Remarks:: This member function is only for realizing a general interface and calls SetStatisticEntryMainComponent()and SetStatisticEntrySubCompoents(). Reimplement these member functions to alter the controllers behavior.

Parameters:

`[in,out]`	rStatisticEntry	reference to the Statistic object where the relevant information should be stored.
`[in]`	pComponentCache	Cache of the component that should set its statistic.
`[in]`	pSessionInfo	Pointer to the session info containing the cache and the statistic the entry is associated with.

Implements FREE::ComponentControllerInterface.

Definition at line 193 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::SessionComponentCache::ComponentIsAssigned(), FREE::DirectSessionComponentAccessor::GetComponent(), FREE::Statistics::GetDictionary(), FREE::SessionInfo::GetStatistic(), FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntryMainComponent(), FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntrySubComponents(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::ComponentPointer FREE::ComponentControllerBase< TControlledComponent >::GetComponent ( const SessionComponentCache * pComponentCache ) const [inline, virtual]

Returns the component managed by the controller and stored in the cache. Reimplement GetComponent() to realize special controller behavior. This version only accesses the component in the cache and returns the pointer.

Parameters:

[in] pComponentCache Pointer to the component cache.

Returns:: Smartpointer to the component.

Definition at line 227 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::ComponentControllerInterface::ControllerID(), FREE::DirectSessionComponentAccessor::GetComponent(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetGenericComponent().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetComponent	(	ComponentType *	pComponent,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Stores the passed component in the passed cache.
Reimplement SetComponent() to realize special controller behavior. This version simply stores the component in the cache.

Parameters:

`[in]`	pComponent	Pointer to the component that should be set.
`[in]`	pComponentCache	Pointer to the component cache.

Definition at line 249 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::ComponentControllerInterface::ControllerID(), FREE::DirectSessionComponentAccessor::SetComponent(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::SetGenericComponent().

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::GenericComponentPointer FREE::ComponentControllerBase< TControlledComponent >::GetGenericComponent ( const SessionComponentCache * pComponentCache ) const [inline, virtual]

Returns the component managed by the controller as generic component. Reimplement GetGenericComponent() to realize special controller behavior. This version just calls GetComponent and casts the result.

Parameters:

[in] pComponentCache Pointer to the component cache.

Returns:: Smartpointer to the generic component.

Implements FREE::ComponentControllerInterface.

Definition at line 270 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::ComponentControllerInterface::ControllerID(), and FREE::ComponentControllerBase< TControlledComponent >::GetComponent().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetGenericComponent	(	GenericComponentType *	pGenericComponent,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Stores the passed generic component in the passed cache.
Reimplement SetGenericComponent() to realize special controller behavior. This version just casts the passed component and calls SetComponent.

Parameters:

`[in]`	pGenericComponent	Pointer to the component that should be set.
`[in]`	pComponentCache	Pointer to the component cache.

Definition at line 289 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::ComponentControllerInterface::ControllerID(), and FREE::ComponentControllerBase< TControlledComponent >::SetComponent().

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::GenericComponentType * FREE::ComponentControllerBase< TControlledComponent >::GetSubComponent	(	SessionComponentCache *	pMainComponentCache,
		const ComponentID	compID
	)			const `[inline, virtual]`

Returns the subcomponent specified by the ComponentID. If the component ID is not defined, the return is NULL.
Reimplement GetSubComponentCasted() function to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	pMainComponentCache	Pointer to the main component cache.
`[in]`	compID	ID specifying the wanted subcomponent.

Returns:: Pointer to the subcomponent. NULL if component does not exist.

Implements FREE::ComponentControllerInterface.

Definition at line 309 of file freControllerBase.txx.

References FREE::SessionComponentCache::ComponentIsAssigned(), FREE::DirectSessionComponentAccessor::GetComponent(), FREE::ComponentControllerBase< TControlledComponent >::GetSubComponentCasted(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetSubComponent	(	SessionComponentCache *	pMainComponentCache,
		GenericComponentType *	pSubComponent,
		const ComponentID	compID
	)			const `[inline]`

Sets a subcomponent specified by the ComponentID.
Reimplement SetSubComponentCasted() function to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	pSubComponent	Pointer to the subcomponent which should be set.
`[in]`	pMainComponentCache	Pointer to the main component cache, containing the main component which should receive the component.
`[in]`	compID	ID specifying the subcomponent within the main component.

Definition at line 322 of file freControllerBase.txx.

References FREE::DirectSessionComponentAccessor::GetComponent(), FREE::ComponentControllerBase< TControlledComponent >::SetSubComponentCasted(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::BuildSubComponents().

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::GenericMediaPointer FREE::ComponentControllerBase< TControlledComponent >::GetMedia	(	const MediaID &	mediaID,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, virtual]`

Returns the media specified by the MediaID. Reimplement GetMediaCasted() to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pComponentCache	Pointer to the component cache.
`[in]`	pSessionInfo	Pointer to the session info.

Returns:: Smartpointer to the media.

Remarks:: If media is unknown to controller an exception will be thrown.

Implements FREE::ComponentControllerInterface.

Definition at line 335 of file freControllerBase.txx.

References FREE::SessionComponentCache::ComponentIsAssigned(), FREE::DirectSessionComponentAccessor::GetComponent(), FREE::ComponentControllerBase< TControlledComponent >::GetMediaCasted(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetMedia	(	const MediaID &	mediaID,
		GenericMediaType *	pMedia,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline]`

Sets a media specified by the MediaID.
Reimplement SetMediaCasted() to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pMedia	Pointer to the media that should be set.
`[in]`	pComponentCache	Pointer to the component cache.
`[in]`	pSessionInfo	Pointer to the session info.

Definition at line 348 of file freControllerBase.txx.

References FREE::SessionComponentCache::ComponentIsAssigned(), FREE::DirectSessionComponentAccessor::GetComponent(), FREE::ComponentControllerBase< TControlledComponent >::SetMediaCasted(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

ValidityTag::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetMediaValidityTag	(	const MediaID &	mediaID,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Retrieves the validity tag of the media specified by the mediaID. The tag is used to decide if a media component is outdated or up to date. It determines the time when the medium was actualized the last time. This can be used by other controllers that link to the media to decide if they may be outdated.
Reimplement GetMediaValidityTag() to realize special controller behavior.
This version checks the cache repository for an element with key "MediaValidityTag_[mediaID]" and returns the ValidityTag. (e.g.: mediaID = finalImage -> key = MediaValidityTag_finalImage). If no element exists with this key, but the media is defined in the controller profile, a NULL-ValidityTag will be returned (always outdated compared to others). If neither an element nor a profile entry can be found, an exception will be thrown.

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pComponentCache	Pointer to the component cache.

Returns:: ValidityTag of the media. NULL-ValidityTag if no tag is yet defined for the media.

Implements FREE::ComponentControllerInterface.

Reimplemented in FREE::MediaActualizerController, FREE::MediaBridgeController, FREE::MediaContainerController, and FREE::MediaDrainController.

Definition at line 361 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::SessionComponentCache::Controller(), FREE::SessionComponentCache::ControllerIsAssigned(), FREE::ComponentControllerInterface::GetProfile(), FREE::DirectSessionComponentAccessor::GetRepositoryElement(), FREE::SessionComponentRepositoryKeys::MediaValidity(), FREE::ValidityTag::NewNull(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetMediaValidityTagRequirement().

Here is the call graph for this function:

template<class TControlledComponent>

ValidityTag::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetMediaValidityTagRequirement	(	const MediaID &	mediaID,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Retrieves the validity tag requirement of the media specified by the mediaID. The requirement is the most up to date ValidityTag in the dependency chain of a media component.
Reimplement GetMediaValidityTagRequirement() to realize special controller behavior accordingly a certain dependency chain.
This version returns only the ValidityTag of the specified media; thus the media has no dependencies.

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pComponentCache	Pointer to the component cache.

Returns:: ValidityTag requirement

Implements FREE::ComponentControllerInterface.

Definition at line 402 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::GetMediaValidityTag().

Here is the call graph for this function:

template<class TControlledComponent>

std::string FREE::ComponentControllerBase< TControlledComponent >::GetMediaControllerID	(	const MediaID &	mediaID,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Retrieves the ID of the actual controller of the given media. Every controller has default types/controllers for its media, but they could be invalid by linking media (e.g. media type is intensity image media, but the actually linked medium could be of subtype region image media.).

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pComponentCache	Pointer to the component cache.

Implements FREE::ComponentControllerInterface.

Reimplemented in FREE::MediaActualizerController, FREE::MediaBridgeController, and FREE::MediaContainerController.

Definition at line 411 of file freControllerBase.txx.

References FREE::SessionComponentCache::ControllerIsAssigned(), FREE::csUndefinedController, FREE::CtrlProfile::Media::GetDataType(), FREE::KeyedCollectionBase< TKey, TElement, TIdentifierClass >::GetElement(), FREE::SessionAccessor::GetMediaControllerID(), FREE::ComponentControllerBase< TControlledComponent >::GetProfile(), FREE::ComponentMediaLink::GetSourceIDPath(), FREE::ComponentSetup::MediaLinks(), FREE::SessionComponentCache::Setup(), FREE::SessionComponentCache::SetupIsAssigned(), and throwCtrlExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

Parameter::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetParameter	(	const SessionComponentCache *	pComponentCache,
		const std::string &	sParameterName
	)			const `[inline, virtual]`

Returns a smart pointer to the specified parameter which is provided by the component controller. To address the component, parameter, layer and value index an IDPath is used: ComponentName\.. (e.g. component@StepSize)

Remarks:: The parameter is passed as a smart pointer because it could be possible that the controller has generated the parameter values explicitly for this call (e.g. Parameter with access type "get") and is not responsible for the deallocation; this will be handled by the smart pointer.

Parameters:

`[in]`	pComponentCache	Pointer to component where the parameter should be located.
`[in]`	sParameterName	Name of the parameter with the wanted value.

Returns:: Smart pointer with the parameter. If the smart pointer is NULL the specified parameter couldn't be found. (See remarks concerning the result nature)

Implements FREE::ComponentControllerInterface.

Definition at line 438 of file freControllerBase.txx.

References FREE::ParameterCollection::GetParameter(), FREE::ComponentSetup::Parameters(), FREE::SessionComponentCache::Setup(), FREE::SessionComponentCache::SetupIsAssigned(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetParameterValue(), and FREE::ComponentControllerBase< TControlledComponent >::SetParameterValue().

Here is the call graph for this function:

template<class TControlledComponent>

std::string FREE::ComponentControllerBase< TControlledComponent >::GetParameterValue	(	const SessionComponentCache *	pComponentCache,
		const std::string &	sParameterName,
		const Parameter::ValueCountType	iItemPos = `0`,
		const Parameter::LayerCountType	iLayer = `0`
	)			const `[inline, virtual]`

Returns the specified value of a parameter. The value can be stored in the component setup, generated by the controller or recieved from anywhere else. The default behaviour is to look for the parameter in the component setup, if the parameter or value do not exist, an exception will be raised. Reimplement GetParameter() to realize special controller behavior.

Remarks:: For convenience use the SessionAccessor to retrieve the parameter value. SessionAccessor offers overloaded setter and getter for different value types and manages the conversion. For the controller itself this was skipped to keep the controller interface as slim as possible.

Parameters:

`[in]`	pComponentCache	Pointer to the component cache.
`[in]`	sParameterName	Name of the parameter that should be retrieved.
`[in]`	iItemPos	Index of the parameter value that should be retrieved.
`[in]`	iLaxer	Index of the parameter layer the value can be found.

Returns:: Value as string.

Implements FREE::ComponentControllerInterface.

Definition at line 451 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::GetParameter(), FREE::SessionComponentCache::SetupIsAssigned(), throwCtrlExceptionMacro, and throwExceptionMacro.

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetParameterValue	(	SessionComponentCache *	pComponentCache,
		const std::string &	sParameterName,
		const std::string &	sValue,
		const Parameter::ValueCountType	iItemPos = `0`,
		const Parameter::LayerCountType	iLayer = `0`
	)			const `[inline, virtual]`

Sets the specified value of a parameter. The default behaviour is to look for the parameter in the component setup and set it there, if the parameter or value do not exist, or if the profile doesn't allow the setting of the value an exception will be raised. Reimplement SetParameter() to realize special controller behavior.

Remarks:: For convenience use the SessionAccessor to set the parameter value. SessionAccessor offers overloaded setter and getter for different value types and manages the conversion. For the controller itself this was skipped to keep the controller interface as slim as possible.

Parameters:

`[in]`	pComponentCache	Pointer to the component cache.
`[in]`	sParameterName	Name of the parameter that should be retrieved.
`[in]`	sValue	The new value that schould be set.
`[in]`	iItemPos	Index of the parameter value that should be retrieved.
`[in]`	iLayer	Index of the parameter layer the value can be found.

Returns:: Value as string.

Implements FREE::ComponentControllerInterface.

Definition at line 469 of file freControllerBase.txx.

References FREE::DAAny, FREE::DASet, FREE::CtrlProfile::Parameter::GetAccess(), FREE::ComponentControllerBase< TControlledComponent >::GetParameter(), FREE::ComponentControllerBase< TControlledComponent >::GetProfile(), FREE::SessionComponentCache::SetupIsAssigned(), throwCtrlExceptionMacro, throwExceptionMacro, and FREE::Convert::ToStr().

Here is the call graph for this function:

template<class TControlledComponent>

ValidityTag::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetParameterValidityTag	(	const std::string &	sParameterName,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Retrieves the validity tag of the parameter specified by sParameterName. The tag is used to decide if a parameter is outdated or up to date. It determines the time when the media was actualized the last time. This can be used by other controllers that link to the media to decide if they may be outdated.
Reimplement GetParameterValidityTag() to realize special controller behavior.
This version checks the cache repository for an element with key "ParameterValidityTag_[sParameterName]" and returns the ValidityTag. (e.g.: sParameterName = Param1 -> key = ParameterValidityTag_Param1). If no element exists with this key, but the parameter is defined in the controller profile, a NULL-ValidityTag will be returned (always outdated compared to others). If neither an element nor a profile entry can be found, an exception will be thrown.

Parameters:

`[in]`	sParameterName	ID specifying the wanted media.
`[in]`	pComponentCache	Pointer to the component cache.

Returns:: ValidityTag of the parameter. NULL-ValidityTag if no tag is yet defined for the parameter.

Implements FREE::ComponentControllerInterface.

Definition at line 498 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::SessionComponentCache::Controller(), FREE::SessionComponentCache::ControllerIsAssigned(), FREE::ComponentControllerInterface::GetProfile(), FREE::DirectSessionComponentAccessor::GetRepositoryElement(), FREE::ValidityTag::NewNull(), FREE::SessionComponentRepositoryKeys::ParameterValidity(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetParameterValidityTagRequirement().

Here is the call graph for this function:

template<class TControlledComponent>

ValidityTag::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetParameterValidityTagRequirement	(	const std::string &	sParameterName,
		SessionComponentCache *	pComponentCache
	)			const `[inline, virtual]`

Retrieves the validity tag requirement of the parameter specified by sParameterName. The requirement is the most up to date ValidityTag in the dependency chain of a parameter.
Reimplement GetParameterValidityTagRequirement() to realize special controller behavior accordingly a certain dependency chain.
This version returns only the ValidityTag of the specified parameter; thus the parameter has no dependencies.

Parameters:

`[in]`	sParameterName	ID specifying the wanted media.
`[in]`	pComponentCache	Pointer to the component cache.

Returns:: ValidityTag of the parameter. NULL-ValidityTag if no tag is yet defined for the parameter.

Implements FREE::ComponentControllerInterface.

Definition at line 539 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::GetParameterValidityTag().

Here is the call graph for this function:

template<class TControlledComponent>

bool FREE::ComponentControllerBase< TControlledComponent >::MakeCallback	(	const CallbackCtrlEventBase::CallbackType &	callbackID,
		void *	pData,
		SessionComponentCache *	pSender,
		long	threadID = `0`
	)			const `[inline, protected]`

Method is a convenient way to use the fnOnCallback to make a callback with the passed parameters. If fnOnCallback is NULL, no call back will be done.

Parameters:

`[in]`	callbackID	The ID, which specifies the kind of callback.
`[in,out]`	pData	Void pointer to the data passed with or retrieved by the callback (depends of the callback type).
`[in,out]`	pSender	Pointer to the session component cache that is currently processed and has need for a callback.
`[in]`	threadID	ID of the Thread executing the event. By default this value is 0. This ID is not unique over the complete system, it should only be assumed that it is unique in the context of the sender.

Returns:: Returns whether the callback could be made and pData may contain valid data. True: the callback was done, False: no callback was done, pData is not valid.

Definition at line 562 of file freControllerBase.txx.

References FREE::SessionComponentCache::GetIDPath(), and FREE::ControllerNotificator::TriggerCallback().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::NotifyProgress	(	const ProgressCtrlEventBase::StatusID &	statusID,
		const std::string &	sComment,
		SessionComponentCache *	pSender,
		long	threadID = `0`
	)			const `[inline, protected]`

Method is a convenient way to use the fnOnProgress to make a progress notification with the passed parameters. If fnOnProgress is NULL, no notification will be done.

Parameters:

`[in]`	statusID	The ID which specifies the kind of progress.
`[in]`	sComment	String passing additional comments on the progress.
`[in,out]`	pSender	Pointer to the session component cache that is currently processed and has notified a progress.
`[in]`	threadID	ID of the Thread executing the event. By default this value is 0. This ID is not unique over the complete system, it should only be assumed that it is unique in the context of the sender.

Definition at line 574 of file freControllerBase.txx.

References FREE::SessionComponentCache::GetIDPath(), and FREE::ControllerNotificator::TriggerProgressEvent().

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::ComponentPointer FREE::ComponentControllerBase< TControlledComponent >::BuildMainComponent	(	ComponentSetup *	pComponentSetup,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected, virtual]`

This function (called by BuildSetup()) creates an object of the controlled class by the use of the passed setup information and initializes other elements in the cache if required.
In a derived class this function should be overridden if a simple instantiation is not sufficient.

Parameters:

`[in]`	pComponentSetup	The setup information for the component that should be build.
`[in,out]`	pComponentCache	Pointer to the component cache associated with the component. The component will be automatically added to the cache by the BuildSetup()

Returns:: Smart pointer to the newly created component. Will be added to the cache.

Here is the place (in derived classes) to insert code for building the main component and return it. Also the setting of parameters can be done here.

Definition at line 587 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::BuildSetup(), and FREE::ComponentControllerBase< TControlledComponent >::ResetMainComponent().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::BuildSubComponents	(	ComponentSetup *	pParentComponentSetup,
		SessionComponentCache *	pParentComponentCache
	)			const `[inline, protected, virtual]`

This function (called by BuildSetup()) is used to create and add all subcomponents. Therefore the SessionBuilder is used to build the subcomponents.
In a derived class this function should be overridden if a simple creation of all subcomponents is not sufficient.

Parameters:

`[in]`	pComponentSetup	The setup information of the parent component, containing the component setups that should be build.
`[in,out]`	pParentComponentCache	Pointer to the parent component cache of the subcomponent and so component cache of the current component. The subcomponent caches will be added to the component cache.

Definition at line 599 of file freControllerBase.txx.

References FREE::SessionBuilder::BuildComponent(), catchAllNPassMacro, FREE::ComponentSetup::Components(), FREE::DirectSessionComponentAccessor::GetComponent(), FREE::ComponentSetup::GetComponentID(), FREE::KeyedCollectionBase< TKey, TElement, TIdentifierClass >::GetElement(), FREE::ComponentControllerBase< TControlledComponent >::SetSubComponent(), FREE::SessionComponentCache::SubCaches(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::BuildSetup().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::BuildFinalization	(	ComponentSetup *	pComponentSetup,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected, virtual]`

This function (called by BuildSetup()) does any finalization work needed after the main and all subcomponents have been build.
In a derived class this function should be overridden if any behavior has to be implemented.

Parameters:

`[in]`	pComponentSetup	The setup information for the component that should be build.
`[in]`	pComponentCache	Pointer to the component cache of the current component.

Here is the place (in derived classes) to insert code that should be executed after the main component and all specified subcomponents have been build. By default finalization does nothing.

Reimplemented in FREE::SetupOptimizationProcessorController.

Definition at line 632 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::BuildSetup().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeMainComponent	(	ComponentType *	pMainComponent,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo,
		const unsigned int &	iActLevel
	)			const `[inline, protected, virtual]`

This function (called by ActualizeComponent()) actualizes the passed component with the setup information considering the actual resolution level of the ongoing registration. In a derived class this function should be overridden to provide a specific behavior.

Parameters:

`[in,out]`	pMainComponent	Pointer to the main component. Can also be retrieved via component cache, but offered directly and already casted for more convenience.
`[in,out]`	pComponentCache	Pointer to the component cache that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.
`[in]`	iActLevel	Indicates which layer of a parameter should be used, if the parameter is layer sensitive (e.g. as resolution level of a registration). Default is 0.

Here is the place (in derived classes) to insert code for actualizing the managed main component.

Definition at line 642 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::ActualizeComponent().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeSubComponents	(	ComponentType *	pMainComponent,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo,
		const unsigned int &	iActLevel
	)			const `[inline, protected, virtual]`

This function (called by ActualizeComponent()) actualizes all subcomponents with the setup information. In a derived class this function should be overridden if a simple ActualizeComponent() call of all subcomponents is not sufficient.

Parameters:

`[in,out]`	pMainComponent	Pointer to the main component.
`[in,out]`	pComponentCache	Pointer to the component cache that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.
`[in]`	iActLevel	Indicates which layer of a parameter should be used, if the parameter is layer sensitive (e.g. as resolution level of a registration). Default is 0.

Definition at line 653 of file freControllerBase.txx.

References FREE::ComponentControllerInterface::ActualizeComponent(), catchAllNPassMacro, FREE::SessionBuilder::CheckComponentNecessity(), FREE::SessionComponentCache::Controller(), FREE::SessionComponentCache::ControllerIsAssigned(), FREE::SessionComponentCache::GetComponentID(), FREE::SessionComponentCache::SubCaches(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::ActualizeComponent().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeFinalization	(	ComponentType *	pMainComponent,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo,
		const unsigned int &	iActLevel
	)			const `[inline, protected, virtual]`

This function (called by ActualizeComponent()) does any finalization work needed after the main and all subcomponents have been actualized.
In a derived class this function should be overridden if any behavior has to be implemented.

Parameters:

`[in,out]`	pMainComponent	Pointer to the main component.
`[in,out]`	pComponentCache	Pointer to the component cache that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.
`[in]`	iActLevel	Indicates which layer of a parameter should be used if the parameter is layer sensitive (e.g. as resolution level of a registration). Default is 0.

Here is the place (in derived classes) to insert code for actualizing the managed component of registration.

Reimplemented in FREE::SPSAOptimizerController.

Definition at line 680 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::ActualizeComponent().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ResetMainComponent	(	SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, protected, virtual]`

This function (called by ResetComponent()) resets the component of the passed cached. The default implementation is an simple recreation of the component and the reseting in the cache. In a derived class this function should be overridden, to provide a specific behavior.

Parameters:

`[in,out]`	pComponentCache	Pointer to the component cache, that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.

Here is the place (in derived classes) to insert code for resetting the managed main component.

Definition at line 690 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::BuildMainComponent(), catchAllNPassMacro, FREE::ComponentControllerInterface::ControllerID(), FREE::SessionComponentCache::IsActive(), FREE::DirectSessionComponentAccessor::SetComponent(), FREE::SessionComponentCache::Setup(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::ResetComponent().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ResetSubComponents	(	SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, protected, virtual]`

This function (called by ResetComponent()) resets all subcomponents In a derived class this function should be overridden, if a simple ResetComponent() call of all subcomponents is is not sufficient.

Parameters:

`[in,out]`	pComponentCache	Pointer to the component cache, that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.

Definition at line 725 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::SessionComponentCache::Controller(), FREE::SessionComponentCache::ControllerIsAssigned(), FREE::ComponentControllerInterface::ResetComponent(), FREE::SessionComponentCache::SubCaches(), and throwCtrlExceptionMacro.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::ResetComponent().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ResetFinalization	(	SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, protected, virtual]`

This function (called by ResetComponent()) does any finalization work needed after the main and all subcomponents have been reseted.
In a derived class this function should be overridden, if any behavior has to be implemented.

Parameters:

`[in,out]`	pComponentCache	Pointer to the component cache, that should be actualized.
`[in]`	pSessionInfo	Pointer to the session info.

Here is the place (in derived classes) to insert code for the finalization of the resetting process.

Definition at line 750 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::ResetComponent().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntryMainComponent	(	StatisticEntry &	rStatisticEntry,
		ComponentType *	pMainComponent,
		SessionComponentCache *	pMainComponentCache,
		SessionInfo *	pSessionInfo,
		StatisticDictionary &	rDictionary
	)			const `[inline, protected, virtual]`

This function (called by SetStatisticEntry()) records any statistical information of the passed component In a derived class this function should be overridden to provide a specific behavior.

Parameters:

`[in,out]`	rStatisticEntry	reference to the Statistic object, where the relevant information should be stored.
`[in]`	pMainComponent	Pointer to the casted component. Also available via cache, but already casted for convenience.
`[in]`	pMainComponentCache	Pointer to the component cache.
`[in]`	pSessionInfo	Pointer to the session info
`[in,out]`	rDictionary	Dictionary with information about the stored facts (e.g. Type, Name) The entry in the dictionary should set by the controller if needed.

Here is the place (in derived classes) to insert code if any statistical information should be recorded.

Definition at line 759 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntry().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntrySubComponents	(	StatisticEntry &	rStatisticEntry,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo,
		StatisticDictionary &	rDictionary
	)			const `[inline, protected, virtual]`

This function (called by SetStatisticEntry()) records any statistical information of all subcomponents In a derived class this function should be overridden to provide a specific behavior.

Parameters:

`[in,out]`	rStatisticEntry	reference to the Statistic object, where the relevant information should be stored.
`[in]`	pComponentCache	Pointer to the component cache.
`[in]`	pSessionInfo	Pointer to the session info
`[in,out]`	rDictionary	Dictionary with information about the stored facts (e.g. Type, Name) The entry in the dictionary should be set by the controller if needed.

Reimplemented in FREE::SetupOptimizationProcessorController, FREE::ConstrainedOnePlusOneEvolutionarySOOptimizerController, and FREE::OnePlusOneEvolutionarySOOptimizerController.

Definition at line 772 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::SessionBuilder::SetStatisticEntry(), and FREE::SessionComponentCache::SubCaches().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::SetStatisticEntry().

Here is the call graph for this function:

template<class TControlledComponent>

const bool FREE::ComponentControllerBase< TControlledComponent >::CheckCmpActNecessitySubCmp ( const SessionComponentCache * pComponentCache ) const [inline, protected]

This function (called by CheckComponentActualizationNecessity()) checks if any subcomponent requires actualizing when the resolution level will be changed.

Parameters:

[in] pComponentCache The component cache information of the main component.

Returns:: Returns whether at least on of the subcomponents requires an actualization.

Definition at line 790 of file freControllerBase.txx.

References FREE::ComponentControllerInterface::CheckComponentActualizationNecessity(), FREE::SessionComponentCache::Controller(), FREE::SessionComponentCache::ControllerIsAssigned(), and FREE::SessionComponentCache::SubCaches().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::CheckComponentActualizationNecessity().

Here is the call graph for this function:

template<class TControlledComponent>

const bool FREE::ComponentControllerBase< TControlledComponent >::CheckCmpActNecessityMainCmp ( const SessionComponentCache * pComponentCache ) const [inline, protected, virtual]

This function (called by CheckComponentActualizationNecessity()) checks if the component requires actualizing when the resolution level will be changed. In a derived class this function should be overridden, to provide a specific behavior.

Parameters:

[in] pComponentCache The component cache information of the component that should be checked.

Returns:: Returns whether the component requires an actualization.

Definition at line 810 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::GetProfile().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::CheckComponentActualizationNecessity().

Here is the call graph for this function:

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::GenericComponentType * FREE::ComponentControllerBase< TControlledComponent >::GetSubComponentCasted	(	ComponentType *	pMainComponent,
		const ComponentID &	compID,
		SessionComponentCache *	pMainComponentCache
	)			const `[inline, protected, virtual]`

Returns the subcomponent specified by the ComponentID. If the component ID is not defined, the return is NULL.
Reimplement the virtual variant of this member function to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	pMainComponent	Pointer to the casted main component, containing the wanted subcomponent.
`[in]`	compID	ID specifying the wanted subcomponent.
`[in]`	pMainComponentCache	Pointer to the cache of the main component.

Here is the place (in derived classes) to insert code for retrieving subcomponents.

Definition at line 824 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetSubComponent().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetSubComponentCasted	(	GenericComponentType *	pSubComponent,
		ComponentType *	pMainComponent,
		const ComponentID	compID,
		SessionComponentCache *	pMainComponentCache
	)			const `[inline, protected, virtual]`

Sets a subcomponent specified by the ComponentID.
Reimplement the virtual variant of this member function to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	pSubComponent	Pointer to the subcomponent which should be set.
`[in]`	pMainComponent	Pointer to the main component, containing the subcomponent.
`[in]`	pMainComponentCache	Pointer to the cache of the main component.
`[in]`	compID	ID specifying the subcomponent within the main component.

Here is the place (in derived classes) to insert code for setting the passed subcomponent in the main component.

Definition at line 833 of file freControllerBase.txx.

Referenced by FREE::ComponentControllerBase< TControlledComponent >::SetSubComponent().

template<class TControlledComponent>

ComponentControllerBase< TControlledComponent >::GenericMediaPointer FREE::ComponentControllerBase< TControlledComponent >::GetMediaCasted	(	const MediaID &	mediaID,
		ComponentType *	pComponent,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, protected, virtual]`

Returns the media specified by the MediaID. If the media ID is not handled, an exception will be thrown.
Reimplement this member function to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pComponent	Pointer to the casted component of the passed cache.
`[in]`	pComponentCache	Pointer to the component cache.
`[in]`	pSessionInfo	Pointer to the session info.

Returns:: Smartpointer to the media.

Remarks:: If media is unknown to controller, an exception will be raised.

Here is the place (in derived classes) to insert code for getting the media of a component. Normally controllers should throw an exception if an unhandled media ID occurs.

Definition at line 843 of file freControllerBase.txx.

References FREE::SessionComponentCache::GetIDPath(), throwCtrlExceptionMacro, and FREE::IDPath::ToStr().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetMedia().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::SetMediaCasted	(	const MediaID &	mediaID,
		GenericMediaType *	pMedia,
		ComponentType *	pComponent,
		SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo
	)			const `[inline, protected, virtual]`

Sets a media component specified by the MediaID.
Reimplement this member function to realize special controller behavior. This version is only for establishing a generic interface.

Parameters:

`[in]`	mediaID	ID specifying the wanted media.
`[in]`	pMedia	Pointer to the media that should be set.
`[in,out]`	pComponent	Pointer to the casted component of the passed cache.
`[in,out]`	pComponentCache	Pointer to the component cache.
`[in]`	pSessionInfo	Pointer to the session info.

Here is the place (in derived classes) to insert code for setting the media of a component. Normally controllers should throw an exception if an unhandled media ID occurs.

Definition at line 854 of file freControllerBase.txx.

References FREE::SessionComponentCache::GetIDPath(), throwCtrlExceptionMacro, and FREE::IDPath::ToStr().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::SetMedia().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeMediaValidityTag	(	const MediaID &	mediaID,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected]`

Actualizes the ValidityTag of a specified media

Parameters:

`[in]`	mediaID	ID specifying the media.
`[in,out]`	pComponentCache	Pointer to the component cache containing the media.

Definition at line 866 of file freControllerBase.txx.

References FREE::SessionComponentRepositoryKeys::MediaValidity(), FREE::ValidityTag::New(), and FREE::DirectSessionComponentAccessor::SetRepositoryElement().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeParameterValidityTag	(	const std::string &	sParameterName,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected]`

Actualizes the ValidityTag of a specified paramter

Parameters:

`[in]`	sParameterName	Name of the parameter.
`[in,out]`	pComponentCache	Pointer to the component cache containing the parameter.

Definition at line 875 of file freControllerBase.txx.

References FREE::ValidityTag::New(), FREE::SessionComponentRepositoryKeys::ParameterValidity(), and FREE::DirectSessionComponentAccessor::SetRepositoryElement().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::ActualizeValidityTag	(	const std::string &	sID,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected]`

Actualizes the ValidityTag of a specified element (no media or parameter)

Parameters:

`[in]`	sID	Name of the element.
`[in,out]`	pComponentCache	Pointer to the component cache containing the tag.

Definition at line 884 of file freControllerBase.txx.

References FREE::ValidityTag::New(), FREE::DirectSessionComponentAccessor::SetRepositoryElement(), and FREE::SessionComponentRepositoryKeys::Validity().

Here is the call graph for this function:

template<class TControlledComponent>

ValidityTag::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetValidityTag	(	const std::string &	id,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected, virtual]`

Retrieves the validity tag of the element specified by the id. The tag is used to decide if a controlled aspect is outdated or up to date. Unlike the other ValidityTag getter this one is only used internally by the controller for managing validities. (e.g. if the registration process is up to date even if no result media are computed yet).
Reimplement GetValidityTag() to realize special controller behavior.
This version checks the cache repository for an element with key "ValidityTag_[ID]" and returns the ValidityTag. If no element exists an exception will be thrown.

Parameters:

`[in]`	ID	Specifying the wanted element.
`[in]`	pComponentCache	Pointer to the component cache.

Returns:: ValidityTag of the element.

Definition at line 893 of file freControllerBase.txx.

References catchAllNPassMacro, FREE::DirectSessionComponentAccessor::GetRepositoryElement(), FREE::ValidityTag::NewNull(), throwCtrlExceptionMacro, and FREE::SessionComponentRepositoryKeys::Validity().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetValidityTagRequirement().

Here is the call graph for this function:

template<class TControlledComponent>

ValidityTag::Pointer FREE::ComponentControllerBase< TControlledComponent >::GetValidityTagRequirement	(	const std::string &	id,
		SessionComponentCache *	pComponentCache
	)			const `[inline, protected, virtual]`

Retrieves the validity tag requirement of the element specified by the id. The requirement is the most up to date ValidityTag in the dependency chain of an element.
Unlike the other ValidityTagRequirement getter this one is only used internally by the controller for managing validities. (e.g. if the registration process is up to date even if no result media are computed yet).
Reimplement GetValidityTagRequirement() to realize special controller behavior for a certain dependency chain.
This version returns only the ValidityTag of the specified media; thus the element has no dependencies.

Parameters:

`[in]`	ID	Specifying the wanted element.
`[in]`	pComponentCache	Pointer to the component cache.

Returns:: ValidityTag of the element.

Definition at line 923 of file freControllerBase.txx.

References FREE::ComponentControllerBase< TControlledComponent >::GetValidityTag().

Here is the call graph for this function:

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::GenerateProfile	(	CtrlProfile::ControllerProfile &	profile,
		const SessionComponentCache *	pComponentCache,
		bool	bRegardOldSetup
	)			const `[inline, protected, virtual]`

Adjusts the current profile according to the definitions of the controller.
Method should call the superclass variant to regard demands of basic controllers.

Parameters:

`[in,out]`	profile	Reference of the current profile.
`[in]`	pComponentCache	Pointer to the cache indicating the location of the component that should be profiled. This pointer can be null. In this case only a default profile that isn't context sensitive is wanted (others aren't possible anyway)
`[in]`	bRegardOldSetup	If true, the setup of pComponentCache is valid and should be regarded when the profile is generated. Otherwise just use defaults if setup information is needed.

Definition at line 933 of file freControllerBase.txx.

Referenced by FREE::SetupOptimizationProcessorController::GenerateProfile(), FREE::ROICoupleControllerBase< FREE::ImageMaskedROICouple< VImageDimension > >::GenerateProfile(), FREE::ROIControllerBase< FREE::ImageROIBase< 3 > >::GenerateProfile(), and FREE::ComponentControllerBase< TControlledComponent >::GetProfile().

template<class TControlledComponent>

void FREE::ComponentControllerBase< TControlledComponent >::GenerateProfileTemplateRealization	(	CtrlProfile::ControllerProfile &	profile,
		const SessionComponentCache *	pComponentCache,
		const ComponentSetup &	oldSetup
	)			const `[inline, protected, virtual]`

This method is called by GetProfile() after GenerateProfile was executed. It is used to enlist profile specification for media, subcomponents and parameters that can be found in the old setup and are based on a template defined in the profile.
This realization is needed to have profiles that also covers setup elements based on a templates. Otherwise because of a unkown ID application utalizing the profile couldn't determine if a setup element is legal or not. This method will only be called if a cache was passed with GetProfile and the cache contains an old setup.

Parameters:

`[in,out]`	profile	Reference of the current profile.
`[in]`	pComponentCache	Pointer to the cache indicating the location of the component that should be profiled.
`[in]`	oldSetup	Reference of the old setup that may contain parameters, subcomponents or media that may be based on templates.

Definition at line 942 of file freControllerBase.txx.

References FREE::ComponentSetup::Components(), FREE::ComponentSetup::GetComponentID(), FREE::KeyedCollectionBase< TKey, TElement, TIdentifierClass >::GetElement(), FREE::ComponentMediaLink::GetMediaID(), FREE::ParameterCollection::GetParameter(), FREE::Parameter::GetParameterName(), FREE::ComponentSetup::GetTemplateID(), FREE::ComponentMediaLink::GetTemplateID(), FREE::Parameter::GetTemplateID(), FREE::ComponentSetup::IsTemplateBased(), FREE::ComponentMediaLink::IsTemplateBased(), FREE::Parameter::IsTemplateBased(), FREE::ComponentSetup::MediaLinks(), FREE::CtrlProfile::ControllerProfileBase::MediaMap(), FREE::CtrlProfile::SubComponent::New(), FREE::CtrlProfile::Media::New(), FREE::CtrlProfile::Parameter::New(), FREE::CtrlProfile::ControllerProfileBase::Parameters(), FREE::ComponentSetup::Parameters(), FREE::CollectionBase< TElement, TStorageType >::Size(), FREE::ParameterCollection::Size(), and FREE::CtrlProfile::ControllerProfileBase::SubComponents().

Referenced by FREE::ComponentControllerBase< TControlledComponent >::GetProfile().

Here is the call graph for this function:

template<class TControlledComponent>

StatisticEntry * FREE::ComponentControllerBase< TControlledComponent >::AddStatisticEntry	(	SessionComponentCache *	pComponentCache,
		SessionInfo *	pSessionInfo,
		const std::string &	sName,
		const std::string &	sDescription
	)			const `[inline, protected, virtual]`

Helper function that checks if the passed session info has a statistic If a statistic exists a new statistic entry will be added as child to the current entry. Also a StatisticEntryDefinition will be added to the statistic dictonary if not existant. Name and description of the entry are passed with the function call. ControllerID and IDPath are gathered via pComponentCache.

Parameters:

	pComponentCache	Pointer to the component cache that should add the entry.
	pSessionInfo	Pointer to the session info containing the cache and the statistic.
	sName	Name of the entry.
	sDescription	Description of the entry.

Returns:: Returns the pointer the added entry. The pointer may be NULL if no entry can be added. One reason is that the session has no statistic, becaus no statistic is wanted.

Definition at line 1053 of file freControllerBase.txx.

References FREE::StatisticDictionary::AddEntryDefinition(), FREE::StatisticData::CreateChildEntry(), FREE::SessionComponentCache::GetControllerID(), FREE::StatisticData::GetCurrentEntryID(), FREE::Statistics::GetData(), FREE::Statistics::GetDictionary(), FREE::StatisticDictionary::GetEntryDefinitionByName(), FREE::SessionComponentCache::GetIDPath(), FREE::StatisticEntryDefinition::GetRefID(), FREE::SessionInfo::GetStatistic(), FREE::StatisticEntry::SetRefID(), and throwCtrlExceptionMacro.

Here is the call graph for this function:


Public Types
typedef ComponentControllerInterface::GenericComponentType	GenericComponentType
typedef ComponentControllerInterface::GenericComponentPointer	GenericComponentPointer
typedef TControlledComponent	ComponentType
typedef ComponentType::Pointer	ComponentPointer
typedef ComponentControllerInterface::GenericMediaType	GenericMediaType
typedef ComponentControllerInterface::GenericMediaPointer	GenericMediaPointer
typedef ComponentControllerInterface::AffectedElementListType	AffectedElementListType
Public Member Functions
virtual const char *	GetNameOfClass () const
virtual CtrlProfile::ControllerProfile::Pointer	GetProfile (const SessionComponentCache *pComponentCache) const
virtual AffectedElementListType	GetAffectedProfileElements (const IDPath &affectorID, SessionComponentCache pComponentCache, const ComponentSetup pNewAffectorSetup=0) const
virtual bool	ControllerIsResponsible (const GenericComponentType *pComponent) const
virtual void	InitializeSetup (ComponentSetup pComponentSetup, SessionComponentCache pComponentCache) const
virtual SessionComponentCache::Pointer	BuildSetup (ComponentSetup pComponentSetup, SessionComponentCache pParentComponentCache) const
const bool	CheckComponentActualizationNecessity (const SessionComponentCache *pComponentCache) const
void	ActualizeComponent (SessionComponentCache pComponentCache, SessionInfo pSessionInfo, const unsigned int &iActiveLayer=0) const
void	ResetComponent (SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
void	SetStatisticEntry (StatisticEntry &rStatisticEntry, SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
virtual ComponentPointer	GetComponent (const SessionComponentCache *pComponentCache) const
virtual void	SetComponent (ComponentType pComponent, SessionComponentCache pComponentCache) const
virtual GenericComponentPointer	GetGenericComponent (const SessionComponentCache *pComponentCache) const
virtual void	SetGenericComponent (GenericComponentType pGenericComponent, SessionComponentCache pComponentCache) const
GenericComponentType *	GetSubComponent (SessionComponentCache *pMainComponentCache, const ComponentID compID) const
void	SetSubComponent (SessionComponentCache pMainComponentCache, GenericComponentType pSubComponent, const ComponentID compID) const
GenericMediaPointer	GetMedia (const MediaID &mediaID, SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
void	SetMedia (const MediaID &mediaID, GenericMediaType pMedia, SessionComponentCache pComponentCache, SessionInfo *pSessionInfo) const
virtual ValidityTag::Pointer	GetMediaValidityTag (const MediaID &mediaID, SessionComponentCache *pComponentCache) const
virtual ValidityTag::Pointer	GetMediaValidityTagRequirement (const MediaID &mediaID, SessionComponentCache *pComponentCache) const
virtual std::string	GetMediaControllerID (const MediaID &mediaID, SessionComponentCache *pComponentCache) const
virtual Parameter::Pointer	GetParameter (const SessionComponentCache *pComponentCache, const std::string &sParameterName) const
virtual std::string	GetParameterValue (const SessionComponentCache *pComponentCache, const std::string &sParameterName, const Parameter::ValueCountType iItemPos=0, const Parameter::LayerCountType iLayer=0) const
virtual void	SetParameterValue (SessionComponentCache *pComponentCache, const std::string &sParameterName, const std::string &sValue, const Parameter::ValueCountType iItemPos=0, const Parameter::LayerCountType iLayer=0) const
virtual ValidityTag::Pointer	GetParameterValidityTag (const std::string &sParameterName, SessionComponentCache *pComponentCache) const
virtual ValidityTag::Pointer	GetParameterValidityTagRequirement (const std::string &sParameterName, SessionComponentCache *pComponentCache) const
virtual	~ComponentControllerBase ()
Protected Member Functions
	ComponentControllerBase ()
bool	MakeCallback (const CallbackCtrlEventBase::CallbackType &callbackID, void pData, SessionComponentCache pSender, long threadID=0) const
void	NotifyProgress (const ProgressCtrlEventBase::StatusID &statusID, const std::string &sComment, SessionComponentCache *pSender, long threadID=0) const
virtual ComponentPointer	BuildMainComponent (ComponentSetup pComponentSetup, SessionComponentCache pComponentCache) const
virtual void	BuildSubComponents (ComponentSetup pParentComponentSetup, SessionComponentCache pParentComponentCache) const
virtual void	BuildFinalization (ComponentSetup pComponentSetup, SessionComponentCache pComponentCache) const
virtual void	ActualizeMainComponent (ComponentType pMainComponent, SessionComponentCache pComponentCache, SessionInfo *pSessionInfo, const unsigned int &iActLevel) const
virtual void	ActualizeSubComponents (ComponentType pMainComponent, SessionComponentCache pComponentCache, SessionInfo *pSessionInfo, const unsigned int &iActLevel) const
virtual void	ActualizeFinalization (ComponentType pMainComponent, SessionComponentCache pComponentCache, SessionInfo *pSessionInfo, const unsigned int &iActLevel) const
virtual void	ResetMainComponent (SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
virtual void	ResetSubComponents (SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
virtual void	ResetFinalization (SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
virtual void	SetStatisticEntryMainComponent (StatisticEntry &rStatisticEntry, ComponentType pMainComponent, SessionComponentCache pMainComponentCache, SessionInfo *pSessionInfo, StatisticDictionary &rDictionary) const
virtual void	SetStatisticEntrySubComponents (StatisticEntry &rStatisticEntry, SessionComponentCache pComponentCache, SessionInfo pSessionInfo, StatisticDictionary &rDictionary) const
const bool	CheckCmpActNecessitySubCmp (const SessionComponentCache *pComponentCache) const
virtual const bool	CheckCmpActNecessityMainCmp (const SessionComponentCache *pComponentCache) const
virtual GenericComponentType *	GetSubComponentCasted (ComponentType pMainComponent, const ComponentID &compID, SessionComponentCache pMainComponentCache) const
virtual void	SetSubComponentCasted (GenericComponentType pSubComponent, ComponentType pMainComponent, const ComponentID compID, SessionComponentCache *pMainComponentCache) const
virtual GenericMediaPointer	GetMediaCasted (const MediaID &mediaID, ComponentType pComponent, SessionComponentCache pComponentCache, SessionInfo *pSessionInfo) const
virtual void	SetMediaCasted (const MediaID &mediaID, GenericMediaType pMedia, ComponentType pComponent, SessionComponentCache pComponentCache, SessionInfo pSessionInfo) const
void	ActualizeMediaValidityTag (const MediaID &mediaID, SessionComponentCache *pComponentCache) const
void	ActualizeParameterValidityTag (const std::string &sParameterName, SessionComponentCache *pComponentCache) const
void	ActualizeValidityTag (const std::string &sID, SessionComponentCache *pComponentCache) const
virtual ValidityTag::Pointer	GetValidityTag (const std::string &id, SessionComponentCache *pComponentCache) const
virtual ValidityTag::Pointer	GetValidityTagRequirement (const std::string &id, SessionComponentCache *pComponentCache) const
virtual void	GenerateProfile (CtrlProfile::ControllerProfile &profile, const SessionComponentCache *pComponentCache, bool bRegardOldSetup) const
virtual void	GenerateProfileTemplateRealization (CtrlProfile::ControllerProfile &profile, const SessionComponentCache *pComponentCache, const ComponentSetup &oldSetup) const
virtual StatisticEntry *	AddStatisticEntry (SessionComponentCache pComponentCache, SessionInfo pSessionInfo, const std::string &sName, const std::string &sDescription) const

FREE::ComponentControllerBase< TControlledComponent > Class Template Reference
[Basic controllers]

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

template<class TControlledComponent>
class FREE::ComponentControllerBase< TControlledComponent >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

FREE::ComponentControllerBase< TControlledComponent > Class Template Reference [Basic controllers]

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

template<class TControlledComponent> class FREE::ComponentControllerBase< TControlledComponent >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

FREE::ComponentControllerBase< TControlledComponent > Class Template Reference
[Basic controllers]

template<class TControlledComponent>
class FREE::ComponentControllerBase< TControlledComponent >