freControllerBase.h

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_h
#define __freControllerBase_h

#include "freElementals.h"
#include "freExceptions.h"
#include "freControllerEvents.h"
#include "freComponentSetup.h"
#include "freComponentSetupAdaptor.h"
#include "freControllerProfile.h"
#include "freSessionComponentCache.h"
#include "freSessionInfo.h"
#include "freValidityTag.h"
#include "freImagePolyStorage.h"
#include "freControllerInterface.h"

namespace FREE
{

//Macro for generation of a controller ID
#define freControllerIDMacro( Class, CtrlID )\
        namespace ControllerID {\
                static const char* const Class = CtrlID;\
        }


freControllerIDMacro( ComponentControllerBase, "ComponentBase");
template <class TControlledComponent>
class ComponentControllerBase : public ComponentControllerInterface
{
public:
  typedef ComponentControllerInterface::GenericComponentType GenericComponentType;
  typedef ComponentControllerInterface::GenericComponentPointer GenericComponentPointer;
  typedef TControlledComponent ComponentType;
  typedef typename ComponentType::Pointer ComponentPointer;
  typedef ComponentControllerInterface::GenericMediaType GenericMediaType;
  typedef ComponentControllerInterface::GenericMediaPointer GenericMediaPointer;

  virtual const char *GetNameOfClass() const {return "ComponentControllerBase";};

  virtual CtrlProfile::ControllerProfile::Pointer GetProfile(const SessionComponentCache* pComponentCache) const;

  typedef ComponentControllerInterface::AffectedElementListType AffectedElementListType;

  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:
  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;
};

} //end of namespace FREE

#ifndef ITK_MANUAL_INSTANTIATION
#include "freControllerBase.txx"
#endif

#endif

---