freControllerBase.txx

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freControllerBase.h,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __freControllerBase_txx
#define __freControllerBase_txx

#include "freControllerBase.h"
#include "freComponentSetupCollection.h"
#include "freSessionBuilder.h"
#include "freSessionAccessor.h"
#include "freControllerNotificator.h"

namespace FREE
{



template <class TControlledComponent>
bool
ComponentControllerBase<TControlledComponent>::
ControllerIsResponsible(const GenericComponentType* pComponent) const
{
  if (pComponent==0) return false;

  ComponentPointer smpTemp = ComponentType::New();

  return  pComponent->GetNameOfClass() == smpTemp->GetNameOfClass();
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
InitializeSetup(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
{
  //TODO Wenn auf neue Profile umgestellt wurd sollte es eine Klasse geben die setups für einen Controller anhand seines Profils erzeugt.
  //wahrscheinlich einfach in den Builder. Das ganze eben ins externe verlagern. oder wenn dann schnittstelle ändern. Und dem Controller
  //nur die möglichkeit der Finalisierung lassen. Vermutlich wirklich einfach den standard programieren und Überladungen zulassen

        //if (!pComponentSetup) throwCtrlExceptionMacro("","Error; trying to initialize pComponentSetup with NULL.");

        //pComponentSetup->SetControllerID(ControllerID());
 // pComponentSetup->SetComponentType(ComponentSetup::CTComponent);


        //pComponentSetup->ResetParameters();

        //for (CtrlProfile::ProfileParameters::ElementsCountType paramPos = 0; paramPos<m_Profile->Parameters().Size(); paramPos++)
        //{
        //      CtrlProfile::Parameter* pProfileParameter = m_Profile->Parameters().GetElement(paramPos);

        //      unsigned int iLayerCount = pProfileParameter->GetLayerCount();
        //      if (pProfileParameter->GetIsArbitrarilyLayered())
 //   {
 //     iLayerCount = 0;
 //     if (pProfileParameter->GetHasDefault()) iLayerCount = pProfileParameter->LayerCount();
 //   }
        //      /*if a parameter has no fixed layer count and has no default definition, it will be created with no layer.
 //     Otherwise the default layers will be copied.*/

        //      Parameter* pSetuParameter = pComponentSetup->Parameters().AddParameter(pProfileParameter->GetParameterName(), pProfileParameter->ParameterSize(), iLayerCount);

 //   //Set default values in all layers
 //   for (CtrlProfile::Parameter::LayerCountType iLayerIndex = 0; iLayerIndex<iLayerCount; iLayerIndex++)
 //   {
 //     ParameterLayer* pLayer = pSetuParameter->GetParameterLayer(iLayerIndex);
 //     
 //     //if more layers needed then default layers defined, the use the last default layer for the rest.
 //     int iDefaultLayerIndex = iLayerIndex;
 //     if (iDefaultLayerIndex>pProfileParameter->LayerCount()-1) iDefaultLayerIndex = pProfileParameter->LayerCount()-1;
 //     ParameterLayer* pDefaultLayer = pProfileParameter->GetParameterLayer(iDefaultLayerIndex);

 //     *pLayer = *pDefaultLayer;
 //   }
        //}

        //pComponentSetup->Components().Reset();

        //for (CtrlProfile::ProfileSubComponents::ElementsCountType compPos = 0; compPos<m_Profile->SubComponents().Size(); compPos++)
        //{
        //      CtrlProfile::SubComponent* pComponent = m_Profile->SubComponents().GetElement(compPos);
        //      ComponentSetupCollection::ComponentsCountType index = pComponentSetup->Components().AddElement(pComponent->GetComponentID(), (pComponent->GetIsRequired()>0));
        //      
        //      if (pComponent->GetControllerID()!=csUndefinedController)
        //      {
        //              pComponentSetup->Components().GetElement(index)->SetControllerID(pComponent->GetControllerID());
        //      }
        //}
}

template <class TControlledComponent>
SessionComponentCache::Pointer
ComponentControllerBase<TControlledComponent>::
BuildSetup(ComponentSetup* pComponentSetup, SessionComponentCache* pParentComponentCache) const
{
  if (!pComponentSetup) throwCtrlExceptionMacro("","Error; no component setup specified.");

  try
  {
    const GenericComponentController* pController = (GenericComponentController*)(this);
    SessionComponentCache::Pointer smpCache = SessionComponentCache::New(pParentComponentCache, pComponentSetup, pController, NULL); 
    
    ComponentPointer smpMainComponent = BuildMainComponent(pComponentSetup, smpCache);
    SessionComponentCache::GenericComponentType* pGenericComp = 0;

    if (smpMainComponent.IsNotNull())
    {
      try
      {
        pGenericComp = dynamic_cast<GenericComponentType*>(smpMainComponent.GetPointer());
      }
      catchAllNPassMacro("Error. Try to cast passed component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<smpMainComponent->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
      if (!pGenericComp) throwCtrlExceptionMacro("","Error. Try to cast passed component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<smpMainComponent->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
    }
    else throwCtrlExceptionMacro("","Error. No component created by controller.");
    DirectSessionComponentAccessor::SetComponent(pGenericComp,smpCache);

    BuildSubComponents(pComponentSetup,smpCache);
    BuildFinalization(pComponentSetup,smpCache);
    
    return smpCache;
  }
  catchAllNPassMacro("Unknown error while building component.");
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeComponent(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo, const unsigned int& iActiveLayer) const
{
  if (!pSessionInfo) throwCtrlExceptionMacro("","Error; no session info available, null pointer passed with function call.");
  if (!pComponentCache) throwCtrlExceptionMacro("","Error; no component cache available, null pointer passed with function call.");
  if (pComponentCache->IsActive())
  {
    try
    {
      ComponentType* pCastedComponent = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pComponentCache));

      ActualizeMainComponent(pCastedComponent, pComponentCache, pSessionInfo, iActiveLayer);
      ActualizeSubComponents(pCastedComponent, pComponentCache, pSessionInfo, iActiveLayer);
      ActualizeFinalization(pCastedComponent, pComponentCache, pSessionInfo, iActiveLayer);
    }
    catchAllNPassMacro("Unknown error while actualizing component.");
  }
  else if (SessionBuilder::CheckComponentNecessity(pComponentCache)) throwCtrlExceptionMacro("","No active component cash, but component is necessary.");
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ResetComponent(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  if (!pSessionInfo) throwCtrlExceptionMacro("","Error; no session info available, null pointer passed with function call.");
  if (!pComponentCache) throwCtrlExceptionMacro("","Error; no component cache available, null pointer passed with function call.");
  if (pComponentCache->IsActive())
  {
    try
    {
      ResetMainComponent(pComponentCache, pSessionInfo);
      ResetSubComponents(pComponentCache, pSessionInfo);
      ResetFinalization(pComponentCache, pSessionInfo);
    }
    catchAllNPassMacro("Unknown error while resetting component.");
  }
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetStatisticEntry(StatisticEntry& rStatisticEntry, SessionComponentCache* pComponentCache,
                 SessionInfo* pSessionInfo) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Error; no component cache available, null pointer passed with function call.");
  if (!pSessionInfo) throwCtrlExceptionMacro("","Error; no session info available, null pointer passed with function call.");
  if (!pSessionInfo->GetStatistic()) throwCtrlExceptionMacro("","Error; no statistic in session info available, cannot set statistic entry without statistic.");
  if (!pComponentCache->ComponentIsAssigned()) throwCtrlExceptionMacro("","Error; main component cache has no component.");

  try
  {
    ComponentType* pComponent = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pComponentCache));
    StatisticDictionary& rDictionary = pSessionInfo->GetStatistic()->GetDictionary();
    SetStatisticEntryMainComponent(rStatisticEntry, pComponent, pComponentCache, pSessionInfo, rDictionary);
    SetStatisticEntrySubComponents(rStatisticEntry, pComponentCache, pSessionInfo, rDictionary);
  }
  catchAllNPassMacro("Unknown error while setting step statistic.");
};

template <class TControlledComponent>
const bool
ComponentControllerBase<TControlledComponent>::
CheckComponentActualizationNecessity(const SessionComponentCache* pComponentCache) const
{
        bool result = CheckCmpActNecessityMainCmp(pComponentCache);

        if (!result) result = CheckCmpActNecessitySubCmp(pComponentCache);

        return result;
};


template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::ComponentPointer
ComponentControllerBase<TControlledComponent>::
GetComponent(const SessionComponentCache* pComponentCache) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Error; no cache has been specified. Null pointer was passed instead.");

  SessionComponentCache::GenericComponentPointer genericComp = DirectSessionComponentAccessor::GetComponent(pComponentCache);
  ComponentPointer result;
  
  if (genericComp.IsNotNull())
  {
    try
    {
      result = dynamic_cast<ComponentType*>(genericComp.GetPointer());
    }
    catchAllNPassMacro("Error. Try to cast component stored in cache. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<genericComp->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
  }

  return result;
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetComponent(ComponentType* pComponent, SessionComponentCache* pComponentCache) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Error; no cache has been specified. Null pointer was passed instead.");

  SessionComponentCache::GenericComponentType* pGenericComp = 0;

  if (pComponent)
  {
    try
    {
      pGenericComp = dynamic_cast<GenericComponentType*>(pComponent);
    }
    catchAllNPassMacro("Error. Try to cast passed component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<pComponent->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
  }

  DirectSessionComponentAccessor::SetComponent(pGenericComp,pComponentCache);
}; 

template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::GenericComponentPointer
ComponentControllerBase<TControlledComponent>::
GetGenericComponent(const SessionComponentCache* pComponentCache) const
{
  ComponentPointer smpComp = GetComponent(pComponentCache);
  GenericComponentPointer result;
  if (smpComp.IsNotNull())
  {
    try
    {
      result = dynamic_cast<GenericComponentType*>(smpComp.GetPointer());
    }
    catchAllNPassMacro("Error. Try to cast component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<smpComp->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
  }

  return result;
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetGenericComponent(GenericComponentType* pGenericComponent, SessionComponentCache* pComponentCache) const
{
  ComponentType* pComponent = 0;

  if (pGenericComponent)
  {
    try
    {
      pComponent = dynamic_cast<ComponentType*>(pGenericComponent);
    }
    catchAllNPassMacro("Error. Try to cast passed component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<pGenericComponent->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
  }

  SetComponent(pComponent,pComponentCache);
}; 


template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::GenericComponentType*
ComponentControllerBase<TControlledComponent>::
GetSubComponent(SessionComponentCache* pMainComponentCache, const ComponentID compID) const
{
  if (!pMainComponentCache) throwCtrlExceptionMacro("", "Error; no main component cache available, null pointer passed with function call.");
  if (!pMainComponentCache->ComponentIsAssigned()) throwCtrlExceptionMacro("", "Error; no main component available, null pointer passed with function call.");

  ComponentType* pCastedComponent = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pMainComponentCache));

  return GetSubComponentCasted(pCastedComponent,compID,pMainComponentCache);
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetSubComponent(SessionComponentCache* pMainComponentCache, GenericComponentType* pSubComponent, 
                const ComponentID compID) const
{
  if (!pMainComponentCache) throwCtrlExceptionMacro("", "Error; no main component cache available, null pointer passed with function call.");

  ComponentType* pCastedComponent = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pMainComponentCache));

  SetSubComponentCasted(pSubComponent,pCastedComponent,compID,pMainComponentCache);
}; 

template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::GenericMediaPointer
ComponentControllerBase<TControlledComponent>::
GetMedia(const MediaID& mediaID, SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("", "Error; no component cache available, null pointer passed with function call.");
  if (!pComponentCache->ComponentIsAssigned()) throwCtrlExceptionMacro("", "Error; no component available in cache.");

  ComponentType* pCastedComponent = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pComponentCache));

  return GetMediaCasted(mediaID, pCastedComponent, pComponentCache, pSessionInfo);
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetMedia(const MediaID& mediaID, GenericMediaType* pMedia, SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("", "Error; no component cache available, null pointer passed with function call.");
  if (!pComponentCache->ComponentIsAssigned()) throwCtrlExceptionMacro("", "Error; no component available in cache.");

  ComponentType* pCastedComponent = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pComponentCache));

  SetMediaCasted(mediaID, pMedia, pCastedComponent, pComponentCache, pSessionInfo);
}; 

template <class TControlledComponent>
ValidityTag::Pointer
ComponentControllerBase<TControlledComponent>::
GetMediaValidityTag(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; passed component cache is NULL");

  std::string sElementKey = SessionComponentRepositoryKeys::MediaValidity(mediaID);
  SessionComponentCache::GenericComponentPointer smpGenericTag = DirectSessionComponentAccessor::GetRepositoryElement(sElementKey,pComponentCache);

  if (smpGenericTag.IsNotNull())
  { //there is a tag saved for the media
    ValidityTag::Pointer smpTag;
    try
    {
      smpTag = dynamic_cast<ValidityTag*>(smpGenericTag.GetPointer());
    }
    catchAllNPassMacro("Error; cannot determine the media validity tag. Found a repository element, but element was not of type ValidityTag. MediaID :" << mediaID);
    if (smpTag.IsNull()) throwCtrlExceptionMacro("","Error; cannot determine the media validity tag. Found a repository element, but element was not of type ValidityTag. MediaID :" << mediaID);

    return smpTag;
  }

  //check for a profile entry
        if (!pComponentCache->ControllerIsAssigned()) throwCtrlExceptionMacro("", "Error; validity tag for "<<mediaID<<" cannot be retrieved. No controller avaible. Check if session was correctly initialized.");

  CtrlProfile::ControllerProfile::Pointer smpProfile = pComponentCache->Controller()->GetProfile(pComponentCache);
  CtrlProfile::ProfileMediaMap::ElementType* pProfileEntry = smpProfile->MediaMap().GetElement(mediaID);
  if (pProfileEntry)
  { //there is at least an entry in the profile
    ValidityTag::Pointer smpTag = ValidityTag::NewNull();
    return smpTag;
  }

  // neither a stored ValidityTag nor a profile entry could be found
  // request seems to be invalid -> throw exception
  throwCtrlExceptionMacro("", "Error; media is not specified for this controller. Cannot retrieved any ValidityTag. MediaID: "<<mediaID);

  return ValidityTag::NewNull();
}; 

template <class TControlledComponent>
ValidityTag::Pointer
ComponentControllerBase<TControlledComponent>::
GetMediaValidityTagRequirement(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  //reimplement to realize a certain dependency chain for certain media
  return this->GetMediaValidityTag(mediaID, pComponentCache);
};

template <class TControlledComponent>
std::string
ComponentControllerBase<TControlledComponent>::
GetMediaControllerID(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; passed component cache is NULL");
        if (!pComponentCache->ControllerIsAssigned()) throwCtrlExceptionMacro("", "Error; controller ID for "<<mediaID<<" cannot be retrieved. No controller avaible. Check if session was correctly initialized.");

        //Check if there is a media link
        if (!pComponentCache->SetupIsAssigned()) throwCtrlExceptionMacro("", "Error; controller ID for "<<mediaID<<" cannot be retrieved. No setup avaible to check media links. Check if session was correctly initialized.");
        ComponentMediaLink* pLink = pComponentCache->Setup()->MediaLinks().GetElement(mediaID);
        if (pLink)
        { //there is a link for this media
                return SessionAccessor::GetMediaControllerID(pLink->GetSourceIDPath(),pComponentCache);
        }
        
        //Check if it is a media component of the controlled component
  CtrlProfile::ControllerProfile::Pointer smpProfile = this->GetProfile(pComponentCache);
        CtrlProfile::Media* pMedia = smpProfile->MediaMap().GetElement(mediaID);
        if (pMedia)
        {
    return pMedia->GetDataType();
        }

  return csUndefinedController;
}; 

template <class TControlledComponent>
Parameter::Pointer
ComponentControllerBase<TControlledComponent>::
GetParameter(const SessionComponentCache* pComponentCache, const std::string& sParameterName) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; cannot get parameter "<<sParameterName<<", passed component cache is NULL.");
  if (!pComponentCache->SetupIsAssigned()) throwCtrlExceptionMacro("", "Error; cannot get parameter "<<sParameterName<<", component setup of cache is NULL.");

  Parameter::Pointer smpParam = pComponentCache->Setup()->Parameters().GetParameter(sParameterName);

  return smpParam;
};

template <class TControlledComponent>
std::string
ComponentControllerBase<TControlledComponent>::
GetParameterValue(const SessionComponentCache* pComponentCache, const std::string& sParameterName, const Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; cannot get value of parameter "<<sParameterName<<", passed component cache is NULL.");
  if (!pComponentCache->SetupIsAssigned()) throwCtrlExceptionMacro("", "Error; cannot get value of parameter "<<sParameterName<<", component setup of cache is NULL.");

  Parameter::Pointer smpParam = this->GetParameter(pComponentCache, sParameterName);

  if (smpParam.IsNull())  throwCtrlExceptionMacro("", "Error; cannot get value; parameter "<<sParameterName<<" was not found.");

  std::string sValue;
  if (!smpParam->GetParameterValue(sValue, iItemPos, iLayer)) throwExceptionMacro("Cannot found parameter " << sParameterName<<"  (item pos"<<iItemPos<<"; layer "<<iLayer<<") in component setup.");

  return sValue;
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetParameterValue(SessionComponentCache* pComponentCache, const std::string& sParameterName, const std::string& sValue, const Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; cannot set value of parameter "<<sParameterName<<", passed component cache is NULL.");
  if (!pComponentCache->SetupIsAssigned()) throwCtrlExceptionMacro("", "Error; cannot set value of parameter "<<sParameterName<<", component setup of cache is NULL.");
  
  //check if it profile allowes the setting of the parameter value
  CtrlProfile::ControllerProfile::Pointer smpProfile = this->GetProfile(pComponentCache);
  CtrlProfile::Parameter* pParameter = smpProfile->Parameters().GetElement(sParameterName);
  
  if (pParameter)
  {
    if (!(pParameter->GetAccess() == DAAny) || !(pParameter->GetAccess() == DASet)) throwExceptionMacro("Cannot set parameter value" << sParameterName<<"; parameter has wrong access mode ("<<Convert::ToStr(pParameter->GetAccess())<<").");
  }

  Parameter::Pointer smpParam = this->GetParameter(pComponentCache, sParameterName);
  if (smpParam.IsNull())  throwCtrlExceptionMacro("", "Error; cannot set value; parameter "<<sParameterName<<" was not found.");

  //set the value
  if (!smpParam->SetParameterValue(sValue, iItemPos, iLayer))
  { //setting failed, detect the reason for the failure
    if (smpParam->ParameterSize() <= iItemPos) throwExceptionMacro("Cannot set parameter " << sParameterName<<" (item pos"<<iItemPos<<"; layer "<<iLayer<<"); item pos exceeds size of parameter ("<<smpParam->ParameterSize()<<").");
    if (smpParam->LayerCount() <= iLayer) throwExceptionMacro("Cannot set parameter " << sParameterName<<" (item pos"<<iItemPos<<"; layer "<<iLayer<<"); layer index exceeds layer count of parameter ("<<smpParam->LayerCount()<<").");
    throwExceptionMacro("Cannot set parameter " << sParameterName<<" (item pos"<<iItemPos<<"; layer "<<iLayer<<"); reason unkown");
  }
}; 

template <class TControlledComponent>
ValidityTag::Pointer
ComponentControllerBase<TControlledComponent>::
GetParameterValidityTag(const std::string& sParameterName, SessionComponentCache* pComponentCache) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; passed component cache is NULL");

  std::string sElementKey = SessionComponentRepositoryKeys::ParameterValidity(sParameterName);
  SessionComponentCache::GenericComponentPointer smpGenericTag = DirectSessionComponentAccessor::GetRepositoryElement(sElementKey,pComponentCache);

  if (smpGenericTag.IsNotNull())
  { //there is a tag saved for the media
    ValidityTag::Pointer smpTag;
    try
    {
      smpTag = dynamic_cast<ValidityTag*>(smpGenericTag.GetPointer());
    }
    catchAllNPassMacro("Error; cannot determine the parameter validity tag. Found a repository element, but element was not of type ValidityTag. ParameterName :" << sParameterName);
    if (smpTag.IsNull()) throwCtrlExceptionMacro("","Error; cannot determine the parameter validity tag. Found a repository element, but element was not of type ValidityTag. ParameterName :" << sParameterName);

    return smpTag;
  }

  //check for a profile entry
        if (!pComponentCache->ControllerIsAssigned()) throwCtrlExceptionMacro("", "Error; validity tag for "<<sParameterName<<" cannot be retrieved. No controller avaible. Check if session was correctly initialized.");

  CtrlProfile::ControllerProfile::Pointer smpProfile = pComponentCache->Controller()->GetProfile(pComponentCache);
  CtrlProfile::ProfileParameters::ElementType* pProfileEntry = smpProfile->Parameters().GetElement(sParameterName);
  if (pProfileEntry)
  { //there is at least an entry in the profile
    ValidityTag::Pointer smpTag = ValidityTag::NewNull();
    return smpTag;
  }

  // neither a stored ValidityTag nor a profile entry could be found
  // request seems to be invalid -> throw exception
  throwCtrlExceptionMacro("", "Error; parameter is not specified for this controller. Cannot retrieved any ValidityTag. ParameterName: "<<sParameterName);

  return ValidityTag::NewNull();
}; 

template <class TControlledComponent>
ValidityTag::Pointer
ComponentControllerBase<TControlledComponent>::
GetParameterValidityTagRequirement(const std::string& sParameterName, SessionComponentCache* pComponentCache) const
{
  //reimplement to realize a certain dependency chain for certain parameters
  return this->GetParameterValidityTag(sParameterName, pComponentCache);
};

template <class TControlledComponent>
ComponentControllerBase<TControlledComponent>::
~ComponentControllerBase()
{ 
};

template <class TControlledComponent>
ComponentControllerBase<TControlledComponent>::
ComponentControllerBase()
{
  this->m_ControllerID =  ControllerID::ComponentControllerBase;
  this->m_Description = "Base class for all component controller; not for practical use.";
};

template <class TControlledComponent>
bool
ComponentControllerBase<TControlledComponent>::
MakeCallback(const CallbackCtrlEventBase::CallbackType& callbackID,
             void* pData, SessionComponentCache* pSender, long threadID) const
{
  IDPath path;
  if (pSender) path = pSender->GetIDPath();

  return ControllerNotificator::TriggerCallback(path, callbackID,pData,pSender,threadID);
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
NotifyProgress(const ProgressCtrlEventBase::StatusID& statusID,
               const std::string& sComment,
               SessionComponentCache* pSender, long threadID) const
{
  IDPath path;
  if (pSender) path = pSender->GetIDPath();

  ControllerNotificator::TriggerProgressEvent(path,statusID,sComment,pSender,threadID);
};

template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::ComponentPointer
ComponentControllerBase<TControlledComponent>::
BuildMainComponent(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
{
  ComponentPointer smpComponent = ComponentType::New();

  return smpComponent;
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
BuildSubComponents(ComponentSetup* pParentComponentSetup, SessionComponentCache* pParentComponentCache) const
{
  typedef ComponentSetupCollection::ComponentsCountType IndexType;

        if (!pParentComponentSetup) throwCtrlExceptionMacro("","Error while buildung subcomponent; invalid parent component setup (null pointer).");
        if (!pParentComponentCache) throwCtrlExceptionMacro("","Error while buildung subcomponent; invalid parent component cache. ComponentID: " << pParentComponentSetup->GetComponentID());

  ComponentSetupCollection& rSetups = pParentComponentSetup->Components();
  
  for (IndexType index=0; index<rSetups.Size(); index++)
  {
    ComponentSetup* pSubSetup = rSetups.GetElement(index); 
    SessionComponentCache::Pointer smpSubCache = NULL;

    try
    {
      smpSubCache = SessionBuilder::BuildComponent(pSubSetup,pParentComponentCache);
                        if (smpSubCache.IsNull()) throwCtrlExceptionMacro("","Unable to build valid subcomponent. ComponentID: " << pSubSetup->GetComponentID());

                        pParentComponentCache->SubCaches().AddElement(smpSubCache);

      //Add subcomponent to the main component. Use direct access for component retrieval
      //to avoid circular building/loading of components (e.g. image media)
      GenericComponentPointer smpSubComponent = DirectSessionComponentAccessor::GetComponent(smpSubCache);
      if (smpSubComponent.IsNotNull()) SetSubComponent(pParentComponentCache,smpSubComponent,pSubSetup->GetComponentID());
    }
                catchAllNPassMacro("Error while building subcomponent. ComponentID: " << pSubSetup->GetComponentID());
  }
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
BuildFinalization(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
{
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeMainComponent(ComponentType* pMainComponent,
                       SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                                                                                         const unsigned int& iActLevel) const
{
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeSubComponents(ComponentType* pMainComponent, SessionComponentCache* pComponentCache,
                       SessionInfo* pSessionInfo, const unsigned int& iActLevel) const
{
        typedef SessionComponentCache::ComponentCacheCollectionType::ElementsCountType IndexType;

        for (IndexType index=0; index<pComponentCache->SubCaches().Size(); index++)
  {
    try
    {
                        SessionComponentCache* pSubCache = pComponentCache->SubCaches().GetElement(index);

      if (pSubCache->ControllerIsAssigned())
      {
        pSubCache->Controller()->ActualizeComponent(pSubCache,pSessionInfo,iActLevel);
      }
      else
      {
                                if (SessionBuilder::CheckComponentNecessity(pSubCache)) throwCtrlExceptionMacro("","Error; no controller assigned for component, but component is required. ComponentID: " << pSubCache->GetComponentID());
      }
    }
    catchAllNPassMacro("Error while actualizing subcomponent.");
  }
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeFinalization(ComponentType* pMainComponent, SessionComponentCache* pComponentCache,
                       SessionInfo* pSessionInfo, const unsigned int& iActLevel) const
{
};
 
template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ResetMainComponent(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("","Error while resetting component; invalid parent component cache (null pointer).");
        if (!pSessionInfo) throwCtrlExceptionMacro("","Error while resetting component; invalid session info (null pointer).");

  if (pComponentCache->IsActive())
  {
    try
    {
      ComponentPointer smpMainComponent = BuildMainComponent(pComponentCache->Setup(), pComponentCache);
      SessionComponentCache::GenericComponentType* pGenericComp = 0;

      if (smpMainComponent.IsNotNull())
      {
        try
        {
          pGenericComp = dynamic_cast<GenericComponentType*>(smpMainComponent.GetPointer());
        }
        catchAllNPassMacro("Error. Try to cast passed component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<smpMainComponent->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
        if (!pGenericComp) throwCtrlExceptionMacro("","Error. Try to cast passed component. Seems to be wrong type. Please ensure correct initialisation. Name of component: "<<smpMainComponent->GetNameOfClass()<<" ; ControllerID: "<<this->ControllerID());
      }
      else throwCtrlExceptionMacro("","Error. No component created by controller.");
      DirectSessionComponentAccessor::SetComponent(pGenericComp,pComponentCache);

    }
    catchAllNPassMacro("Unknown error while resetting component.");
  }

};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ResetSubComponents(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("","Error while resetting sub components; invalid parent component cache (null pointer).");
        if (!pSessionInfo) throwCtrlExceptionMacro("","Error while resetting sub components; invalid session info (null pointer).");

        typedef SessionComponentCache::ComponentCacheCollectionType::ElementsCountType IndexType;

        for (IndexType index=0; index<pComponentCache->SubCaches().Size(); index++)
  {
    try
    {
                        SessionComponentCache* pSubCache = pComponentCache->SubCaches().GetElement(index);

      if (pSubCache->ControllerIsAssigned())
      {
        pSubCache->Controller()->ResetComponent(pSubCache,pSessionInfo);
      }
    }
    catchAllNPassMacro("Error while actualizing subcomponent.");
  }
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ResetFinalization(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
{
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetStatisticEntrySubComponents(StatisticEntry& rStatisticEntry, SessionComponentCache* pComponentCache,
                              SessionInfo* pSessionInfo, StatisticDictionary& rDictionary) const
{
  for (unsigned int index=0; index<pComponentCache->SubCaches().Size(); index++)
  {
    try
    {
      SessionComponentCache* pSubCache = (pComponentCache->SubCaches()).GetElement(index);

      SessionBuilder::SetStatisticEntry(rStatisticEntry, pSubCache, pSessionInfo);
    }
    catchAllNPassMacro("Error while setting step statistic of subcomponent.");
  }
};

template <class TControlledComponent>
const bool
ComponentControllerBase<TControlledComponent>::
CheckCmpActNecessitySubCmp(const SessionComponentCache* pComponentCache) const
{
        typedef SessionComponentCache::ComponentCacheCollectionType::ElementsCountType IndexType;

        for (IndexType index=0; index<pComponentCache->SubCaches().Size(); index++)
  {
                SessionComponentCache* pSubCache = pComponentCache->SubCaches().GetElement(index);
      
    if (pSubCache->ControllerIsAssigned())
    {
                        if (pSubCache->Controller()->CheckComponentActualizationNecessity(pSubCache)) return true;
    }
  }

        return false;
};

template <class TControlledComponent>
const bool
ComponentControllerBase<TControlledComponent>::
CheckCmpActNecessityMainCmp(const SessionComponentCache* pComponentCache) const
{
  CtrlProfile::ControllerProfile::Pointer smpProfile = this->GetProfile(pComponentCache);

        for (CtrlProfile::ProfileParameters::ElementsCountType i = 0; i < smpProfile->Parameters().Size(); i++)
        {
                if (smpProfile->Parameters().GetElement(i)->GetIsMultiResDynamic()) return true;
        }
        return false;
};

template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::GenericComponentType*
ComponentControllerBase<TControlledComponent>::
GetSubComponentCasted(ComponentType* pMainComponent, const ComponentID& compID, SessionComponentCache* pMainComponentCache) const
{
  return NULL;
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetSubComponentCasted(GenericComponentType* pSubComponent, ComponentType* pMainComponent,
                      const ComponentID compID, SessionComponentCache* pMainComponentCache) const
  {
  }; 

template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::GenericMediaPointer
ComponentControllerBase<TControlledComponent>::
GetMediaCasted(const MediaID& mediaID, ComponentType* pComponent,
               SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  throwCtrlExceptionMacro("","MediaID ("<<mediaID<<") is unkown and cannot be retrieved. Component: "<<pComponentCache->GetIDPath().ToStr());
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia,
                                                   ComponentType* pComponent,
               SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  throwCtrlExceptionMacro("","MediaID ("<<mediaID<<") is unkown and cannot be set. Component: "<<pComponentCache->GetIDPath().ToStr());
}; 

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeMediaValidityTag(const MediaID& mediaID,
                          SessionComponentCache* pComponentCache) const
{
  DirectSessionComponentAccessor::SetRepositoryElement(SessionComponentRepositoryKeys::MediaValidity(mediaID),ValidityTag::New(),pComponentCache);
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeParameterValidityTag(const std::string& sParameterName,
                              SessionComponentCache* pComponentCache) const
{
  DirectSessionComponentAccessor::SetRepositoryElement(SessionComponentRepositoryKeys::ParameterValidity(sParameterName),ValidityTag::New(),pComponentCache);
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
ActualizeValidityTag(const std::string& sID,
                     SessionComponentCache* pComponentCache) const
{
  DirectSessionComponentAccessor::SetRepositoryElement(SessionComponentRepositoryKeys::Validity(sID),ValidityTag::New(),pComponentCache);
};

template <class TControlledComponent>
ValidityTag::Pointer
ComponentControllerBase<TControlledComponent>::
GetValidityTag(const std::string& id, SessionComponentCache* pComponentCache) const
{
        if (!pComponentCache) throwCtrlExceptionMacro("", "Error; passed component cache is NULL");

  std::string sElementKey = SessionComponentRepositoryKeys::Validity(id);
  SessionComponentCache::GenericComponentPointer smpGenericTag = DirectSessionComponentAccessor::GetRepositoryElement(sElementKey,pComponentCache);

  if (smpGenericTag.IsNotNull())
  { //there is a tag saved for the element
    ValidityTag::Pointer smpTag;
    try
    {
      smpTag = dynamic_cast<ValidityTag*>(smpGenericTag.GetPointer());
    }
    catchAllNPassMacro("Error; cannot determine the validity tag. Found a repository element, but element was not of type ValidityTag. ID :" << id);
    if (smpTag.IsNull()) throwCtrlExceptionMacro("","Error; cannot determine the validity tag. Found a repository element, but element was not of type ValidityTag. ID :" << id);

    return smpTag;
  }

  // no stored ValidityTag could be found
  // request seems to be invalid -> throw exception
  throwCtrlExceptionMacro("", "Error; element ValidityTag is not specified for this controller. Cannot retrieved any ValidityTag. ID: "<< id);

  return ValidityTag::NewNull();
}; 

template <class TControlledComponent>
ValidityTag::Pointer
ComponentControllerBase<TControlledComponent>::
GetValidityTagRequirement(const std::string& id, SessionComponentCache* pComponentCache) const
{
  //reimplement to realize a certain dependency chain for certain element
  return this->GetValidityTag(id, pComponentCache);
};


template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
GenerateProfile(CtrlProfile::ControllerProfile& profile, 
                const SessionComponentCache* pComponentCache,
                bool bRegardOldSetup) const
{
};

template <class TControlledComponent>
void
ComponentControllerBase<TControlledComponent>::
GenerateProfileTemplateRealization(CtrlProfile::ControllerProfile& profile,
                                   const SessionComponentCache* pComponentCache,
                                   const ComponentSetup& oldSetup) const
{
  //browes throw all parameters and search for templated ones
  for ( unsigned int i = 0; i < oldSetup.Parameters().Size(); i++)
  {
    Parameter* pParam = oldSetup.Parameters().GetParameter(i);
    if (pParam->IsTemplateBased())
    { //found a parameter based on a template -> get the parameter profile
      CtrlProfile::Parameter* pParamProfile = profile.Parameters().GetElement(pParam->GetTemplateID());

      if (pParamProfile)
      {//ok there is a profile specification, so add one based on this
        CtrlProfile::Parameter::Pointer smpNewParamProfile = CtrlProfile::Parameter::New();
        smpNewParamProfile->operator = (*pParamProfile); //copy all profile settings
        smpNewParamProfile->SetParameterName(pParam->GetParameterName()); //set new name of profile
        smpNewParamProfile->SetTemplateID(""); //no template anymore
            profile.Parameters().AddElement(smpNewParamProfile);
      }
    }
  }

  //browes throw all media links and search for templated ones
  for ( unsigned int i = 0; i < oldSetup.MediaLinks().Size(); i++)
  {
    ComponentMediaLink* pLink = oldSetup.MediaLinks().GetElement(i);
    if (pLink->IsTemplateBased())
    { //found a media component based on a template -> get the media profile
      CtrlProfile::Media* pMediaProfile = profile.MediaMap().GetElement(pLink->GetTemplateID());

      if (pMediaProfile)
      {//ok there is a profile specification, so add one based on this
        CtrlProfile::Media::Pointer smpNewMediaProfile = CtrlProfile::Media::New();
        smpNewMediaProfile->operator = (*pMediaProfile); //copy all profile settings
        smpNewMediaProfile->SetName(pLink->GetMediaID()); //set new name of profile
        smpNewMediaProfile->SetIsTemplate(false); //no template anymore
            profile.MediaMap().AddElement(smpNewMediaProfile);
      }
    }
  }

  //browes throw all subcomponents and search for templated
  for ( unsigned int i = 0; i < oldSetup.Components().Size(); i++)
  {
    ComponentSetup* pComponent = oldSetup.Components().GetElement(i);
    if (pComponent->IsTemplateBased())
    { //found a subcomponent based on a template -> get the subcomponent profile
      CtrlProfile::SubComponent* pSubCompProfile = profile.SubComponents().GetElement(pComponent->GetTemplateID());

      if (pSubCompProfile)
      {//ok there is a profile specification, so add one based on this
        CtrlProfile::SubComponent::Pointer smpNewSubCompProfile = CtrlProfile::SubComponent::New();
        smpNewSubCompProfile->operator = (*pSubCompProfile); //copy all profile settings
        smpNewSubCompProfile->SetComponentID(pComponent->GetComponentID()); //set new name of profile
        smpNewSubCompProfile->SetIsTemplate(false); //no template anymore
            profile.SubComponents().AddElement(smpNewSubCompProfile);
      }
    }
  }
};

template <class TControlledComponent>
CtrlProfile::ControllerProfile::Pointer
ComponentControllerBase<TControlledComponent>::
GetProfile(const SessionComponentCache* pComponentCache) const
{
  bool bRegardOldSetup = false;
  if (pComponentCache)
  {
    if (pComponentCache->SetupIsAssigned())
    {
      if (pComponentCache->Setup()->GetControllerID() == this->ControllerID())
      {
        bRegardOldSetup = true;
      }
    }
  }

  CtrlProfile::ControllerProfile::Pointer profile = CtrlProfile::ControllerProfile::New();

  //This basic information have already set via the constructor of the controller and its
  //ancestor classes. So just add it to the profile. GenerateProfile() only has to care about
  //parameter, component and media definitions and about requirements.
  profile->ControllerID() = this->m_ControllerID;
  profile->Description() = this->m_Description;
  profile->Inheritance() = this->m_Inheritance;

  this->GenerateProfile(*(profile.GetPointer()),pComponentCache,bRegardOldSetup);

  if (bRegardOldSetup)
  {
    this->GenerateProfileTemplateRealization(*(profile.GetPointer()), pComponentCache, *(pComponentCache->Setup()));
  }

  return profile;
};

template <class TControlledComponent>
typename ComponentControllerBase<TControlledComponent>::AffectedElementListType
ComponentControllerBase<TControlledComponent>::
GetAffectedProfileElements(const IDPath& affectorID,
                           SessionComponentCache* pComponentCache,
                           const ComponentSetup* pNewAffectorSetup) const
{ //normaly no elements are affected
  return AffectedElementListType();
};

template <class TControlledComponent>
StatisticEntry*
ComponentControllerBase<TControlledComponent>::
AddStatisticEntry(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo,
                  const std::string& sName, const std::string& sDescription) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Error while adding statistic entry; invalid component cache (null pointer). Entry name: "<<sName);
  if (!pSessionInfo) throwCtrlExceptionMacro("","Error while adding statistic entry; invalid session info (null pointer). Entry name:"<<sName);

  if (pSessionInfo->GetStatistic()==0) return 0;

  StatisticEntryDefinition* pEntryDef = pSessionInfo->GetStatistic()->GetDictionary().GetEntryDefinitionByName(pComponentCache->GetIDPath(),sName);
  if (!pEntryDef)
  {
    pEntryDef = pSessionInfo->GetStatistic()->GetDictionary().AddEntryDefinition(pComponentCache->GetIDPath(),sName,pComponentCache->GetControllerID(),sDescription);
  }  

  StatisticEntry* pEntry =pSessionInfo->GetStatistic()->GetData().CreateChildEntry(pSessionInfo->GetStatistic()->GetData().GetCurrentEntryID());

  pEntry->SetRefID(pEntryDef->GetRefID());

  return pEntry;
};

} //end of namespace FREE

#endif

---