freSetupManager.cxx

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: freSetupManager.cxx,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.

=========================================================================*/
#include "freSetupManager.h"
#include "freSessionBuilder.h"
#include "freControllerCentral.h"

namespace FREE
{

SetupManager::ControllerListType
SetupManager::
GetPossibleControllers(const IDPath& componentID, const bool& bCheckOnlyHypothetical)
{
  if (m_smpSetup.IsNull()) throwStaticExceptionMacro("Manager has no setup set.");

  ComponentSetup* pComponentSetup = m_smpSetup->GetComponentByIDPath(componentID);
  
  if (!pComponentSetup) throwStaticExceptionMacro("No component setup found under given ID path. ID path: " << ComponentID(componentID));
  
  //Get IDPath of the Parent component
  IDPath parentIDPath;
  if (pComponentSetup->GetParentComponent()) parentIDPath = pComponentSetup->GetParentComponent()->GetIDPath();
  
  //Get the controller list
  typedef ControllerCentral::ControllerListType ListType;
  ListType controllers = ControllerCentral::GetControllers();

  ControllerListType ctrlNames;

  //Check every controller, if he is valid.
  for (ListType::iterator pos = controllers.begin(); pos!=controllers.end(); pos++)
  {
    GenericComponentController* pController = (*pos)->GetController();

    IDPathVectorType refusers;
    IDPathVectorType refused;
    bool bValid = ValidateController(componentID,pController->ControllerID(),refusers,refused);

    //Check if the parent component also refuses 
    bool bParentRefusal = false;
    for (IDPathVectorType::iterator pathPos = refusers.begin(); pathPos!= refusers.end(); pathPos++)
    {
      if (*pathPos == parentIDPath)
      {
        bParentRefusal = true;
        break;
      };
    };

    //Add controller name if valid
    if (bValid || (bCheckOnlyHypothetical && !(bParentRefusal))) ctrlNames.push_back(pController->ControllerID());
  }
  return ctrlNames;
};

bool
SetupManager::
ValidateController(const IDPath& componentID,
                   const std::string& sControllername,
                   IDPathVectorType& rRefusingComponents,
                   IDPathVectorType& rRefusedComponents)
{
  //TODO muss mit den neuen Profilen abgepasst werden und überlegung ob dass nicht auch in eine eigene Klasse soll die sich dann um
  //prüfung der ontologie kümmert.

 // if (!pSetup) throwStaticExceptionMacro("Passed setup is NULL.");

 // GenericComponentController* pController = ControllerCentral::GetController(sControllername);
 // if (!pController) throwStaticExceptionMacro("Specified controller cannot be found. Controller name: " << sControllername);

 // bool bResult = true;

 // CtrlProfile::ControllerProfile::Pointer smpProfile = pController->GetProfile();

 // //Check component trait against constraint cache of setup
 // typedef CtrlProfile::ProfileRequirements::RequirementVectorType RelevantRequirementsType;
        //RelevantRequirementsType constraints = pSetup->GetRequirementCache().GetRequirementsByDestination(componentID);

 // for (RelevantRequirementsType::iterator pos = constraints.begin(); pos!=constraints.end(); pos++)
 // {
 //   if (!(*pos)->ProfileMatchesRequirement(profile))
 //   {
 //     bResult = false;
 //     rRefusingComponents.push_back((*pos)->GetSource());
 //   };
 // };

 // //Check if any yet chosen component interferes with the constraints of the chosen controller
 // for (unsigned int iPos = 0; iPos<profile.Requirements().Size(); iPos++)
 // {
        //      CtrlProfile::ProfileRequirement* pRequirement = profile.Requirements().GetElement(iPos);
 //   IDPath destination = pRequirement->GetDestination();
 //   //adapt destination to the actual component path, so its absolute for the given setup
 //   destination = destination.TransformIDPath(componentID);

 //   //Get profile of the destination component
 //   ComponentSetup* pLtdComponent = pSetup->GetComponentByIDPath(destination);
 //   if (pLtdComponent)
 //   { //component exists, so check it.
 //     if (pLtdComponent->ControllerIsAssigned())
 //     { //a controller is defined, so it must be checked
 //       GenericComponentController* pLtdController = ControllerCentral::GetController(pLtdComponent->GetControllerID());
 //       if (!pLtdController) throwStaticExceptionMacro("Controller of limited component cannot be found, but specified. Controller name: " << pLtdComponent->GetControllerID());
 //   
 //       if (!pRequirement->ProfileMatchesRequirement(pLtdController->Profile()))
 //       {
 //         bResult = false;
 //         rRefusedComponents.push_back(destination);
 //       };
 //     };
 //   };
 // };

 // return bResult;
  return false;
};

bool
SetupManager::
ValidateController(const IDPath& componentID, const std::string& sControllername)
{
  IDPathVectorType refusers;
  IDPathVectorType refused;
  return ValidateController(componentID,sControllername,refusers,refused);
};

void
SetupManager::
InitializeComponentSetup(Setup* pSetup, ComponentSetup* pComponentSetup)
{
  if (pComponentSetup == NULL) throwStaticExceptionMacro("Unable to initialize setup; pComponentSetup is NULL.");

  InitializeComponentSetup(pSetup, pComponentSetup,pComponentSetup->GetControllerID());
};

void
SetupManager::
InitializeComponentSetup(Setup* pSetup, ComponentSetup* pComponentSetup, const std::string& sControllerName)
{
  if (pSetup == NULL) throwStaticExceptionMacro("Unable to initialize setup; pSetup is NULL.");
  if (pComponentSetup == NULL) throwStaticExceptionMacro("Unable to initialize setup; pComponentSetup is NULL.");

  ControllerCentral::TriggerBuildEvent(1,"...initializing "+sControllerName+" @ "+ pComponentSetup->GetIDPath().ToStr(), pComponentSetup);

  if (sControllerName == csUndefinedController)
  {
    ComponentID componentID = pComponentSetup->GetComponentID();
    pComponentSetup->Reset();
    pComponentSetup->SetComponentID(componentID);
  }
  else
  {
    GenericComponentController* pController = ControllerCentral::GetController(sControllerName);
      
    if (!pController) throwStaticExceptionMacro("Controller not found for initialization. Requested controller name: "<<sControllerName);

                if (!ValidateController(pComponentSetup->GetIDPath(),sControllerName)) throwStaticExceptionMacro("Error; chosen controller is not valid for the given setup. ControllerID: " << sControllerName);

    //TODO anpassen auf neue intialisierungs schnittstelle
    //pController->InitializeSetup(pComponentSetup);

    //update Constraint cache
    ActualizeConstraintCache(pSetup,pComponentSetup->GetIDPath(),sControllerName);

                //Check if any subcomponent have a default controller
                for (ComponentSetupCollection::ElementsCountType index=0; index<pComponentSetup->Components().Size(); index++)
                {
                        ComponentSetup* pSubSetup = pComponentSetup->Components().GetElement(index);
                        if (pSubSetup->ControllerIsAssigned()) InitializeComponentSetup(pSetup,pSubSetup);
                }
  }
};

void
SetupManager::
InitializeComponentSetup(ComponentSetup* pComponentSetup, const std::string& sControllerName)
{
  if (pComponentSetup == NULL) throwStaticExceptionMacro("Unable to initialize setup; pComponentSetup is NULL.");

  ControllerCentral::TriggerBuildEvent(1,"...initializing "+sControllerName+" @ "+ pComponentSetup->GetIDPath().ToStr(), pComponentSetup);

  if (sControllerName == csUndefinedController)
  {
    ComponentID componentID = pComponentSetup->GetComponentID();
    pComponentSetup->Reset();
    pComponentSetup->SetComponentID(componentID);
  }
  else
  {
    GenericComponentController* pController = ControllerCentral::GetController(sControllerName);
      
    if (!pController) throwStaticExceptionMacro("Controller not found for initialization. Requested controller name: "<<sControllerName);

    //TODO anpassen auf neue intialisierungs schnittstelle
    //pController->InitializeSetup(pComponentSetup);

                //Check if any subcomponent have a default controller
                for (ComponentSetupCollection::ElementsCountType index=0; index<pComponentSetup->Components().Size(); index++)
                {
                        ComponentSetup* pSubSetup = pComponentSetup->Components().GetElement(index);
                        if (pSubSetup->ControllerIsAssigned()) InitializeComponentSetup(pSubSetup, pSubSetup->GetControllerID());
                }
  }
};

Setup*
SetupManager::
GetSetup() const
{
  return m_smpSetup.GetPointer();
};

void
SetupManager::
SetSetup(Setup* pSetup)
{
  if (m_smpSetup.GetPointer()!=pSetup)
  {
          m_smpSetup = pSetup;
    m_smpRootCache = SessionBuilder::GeneratePassiveComponentCache(pSetup->GetRootComponent());
    m_RequirementCache.Reset();
  }
};

const SessionComponentCache*
SetupManager::
GetSessionCache() const
{
        return m_smpRootCache.GetPointer();
};
  
SessionComponentCache*
SetupManager::
GetSessionCache()
{
        return m_smpRootCache.GetPointer();
};

const SetupManager::ComponentCacheCollectionType&
SetupManager::
GetComponentCaches() const
{
  if (this->m_smpRootCache.IsNotNull())
  {
    return this->m_smpRootCache->SubCaches();
  }
  throwExceptionMacro("Error; cannot retrieve component caches, root cache is NULL. Ensure that session info has been properly builed.");
};

SetupManager::ComponentCacheCollectionType&
SetupManager::
GetComponentCaches()
{
  if (this->m_smpRootCache.IsNotNull())
  {
    return this->m_smpRootCache->SubCaches();
  }
  throwExceptionMacro("Error; cannot retrieve component caches, root cache is NULL. Ensure that session info has been properly builed.");
};

SetupManager::
SetupManager()
{
        m_smpRootCache = 0;
  m_smpSetup = 0;
};

void
SetupManager::
ActualizeConstraintCache(Setup* pSetup, const IDPath& componentID, const std::string& sControllername)
{
  //TODO muss mit den neuen Profilen dann geändert werden, gehört in die gleiche Kategorie wie InitializeSetup etc.

 // if (!pSetup) throwStaticExceptionMacro("Passed setup is NULL.");

 // GenericComponentController* pController = ControllerCentral::GetController(sControllername);
 // if (!pController) throwStaticExceptionMacro("Specified controller cannot be found. Controller name: " << sControllername);

        //const CtrlProfile::ControllerProfile& profile = pController->Profile();

 // //adapt the constraints of the chosen controller and add it to the cache
 // for (unsigned int iPos = 0; iPos<profile.Requirements().Size(); iPos++)
 // {
 //   CtrlProfile::ProfileRequirement::Pointer smpRequirement = CtrlProfile::ProfileRequirement::New();
 //   smpRequirement->operator=(*(profile.Requirements().GetElement(iPos)));

 //   //adapt destination to the actual component path, so its absolute for the given setup
 //   smpRequirement->SetDestination(smpRequirement->GetDestination().TransformIDPath(componentID));
 //   smpRequirement->SetSource(componentID);

 //   pSetup->GetRequirementCache().AddElement(smpRequirement);
 // }
};


void
SetupManager::
ActualizeConstraintCache(Setup* pSetup)
{
  m_RequirementCache.Reset();
  //The is the default constraint to ensure that only registration processors handling the right
  //dimension will be allowed
        CtrlProfile::ProfileOption* pOption = m_RequirementCache.AddRequirement(cIDPEveryone)->AddProfileOption();
        pOption->CheckForIO();

  Setup::SectionVector sections = pSetup->GetSections();
  for (unsigned int i = 0; i<sections.size(); i++)
  {
    ActualizeConstraintCache(pSetup,sections[i]);
  }
};

void
SetupManager::
ActualizeConstraintCache(Setup* pSetup, ComponentSetup* pComponentSetup)
{
  if (pComponentSetup->GetControllerID()!=csUndefinedController)
  {
    ActualizeConstraintCache(pSetup,pComponentSetup->GetIDPath(),pComponentSetup->GetControllerID());
  }

  for (unsigned int i = 0; i<pComponentSetup->Components().Size(); i++)
  {
    ActualizeConstraintCache(pSetup,pComponentSetup->Components().GetElement(i));
  }
};

}//end of namespace FREE

---