freSessionBuilder.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: freSessionBuilder.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.

=========================================================================*/
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include "freSessionBuilder.h"
#include "freExceptions.h"

#include "freControllerCentral.h"
#include "freSessionInfo.h"
#include "freSessionAccessor.h"
#include "freMediaControllerBase.h"

namespace FREE
{

SessionBuilder::
SessionBuilder()
{
}

SessionBuilder::
~SessionBuilder()
{
}

bool
SessionBuilder::
CheckComponentNecessity(const SessionComponentCache* pComponentCache)
{
        if (!pComponentCache) throwStaticExceptionMacro("Error while evaluating component's necessity. Invalid component cache passed (null pointer).");
  if (!pComponentCache->SetupIsAssigned()) throwStaticExceptionMacro("Error while evaluating component's necessity. Component cache has no setup.");

  const SessionComponentCache* pParentCache = pComponentCache->GetParentCache();

  return CheckComponentNecessity(pParentCache,pComponentCache->GetComponentID());
};

bool
SessionBuilder::
CheckComponentNecessity(const SessionComponentCache* pParentCache, const ComponentID& componentID)
{
  if (!pParentCache) return false; //No parent, no requirement.
        if (!pParentCache->ControllerIsAssigned()) return false; //No controller, no requirement.
        
  CtrlProfile::ControllerProfile::Pointer smpProfile = pParentCache->Controller()->GetProfile(pParentCache);

  const CtrlProfile::ProfileSubComponents& rProfilSubComps = smpProfile->SubComponents();
  CtrlProfile::SubComponent* pCompProfil = rProfilSubComps.GetElement(componentID);

        if (!pCompProfil) throwStaticExceptionMacro("Error while evaluating component's necessity. Component was not found in parental profil (ComponentID): "<<componentID);

        if (pCompProfil->GetIsRequired()==0) return false;
        else if (pCompProfil->GetIsRequired()==1) return true;
        else
        {
                for ( CtrlProfile::ProfileSubComponents::ElementsCountType index = 0; index < rProfilSubComps.Size(); index++)
                {
                        CtrlProfile::SubComponent* pOtherProfil = rProfilSubComps.GetElement(index);
                        if ((pOtherProfil->GetComponentID()!=pCompProfil->GetComponentID()) && (pOtherProfil->GetIsRequired()==pCompProfil->GetIsRequired()))
                        { //check if the other component has a controller assigned.
                                const ComponentSetup* pOtherSetup = pParentCache->Setup()->Components().GetElement(pOtherProfil->GetComponentID());
                                if (!pOtherSetup) throwStaticExceptionMacro("Error while evaluating component's necessity. Sibling component has no component setup (ComponentID): " << pOtherProfil->GetComponentID());

                                if (pOtherSetup->ControllerIsAssigned()) return true;
                                //there is at least one other subcomponent in the same requrement group that has a controller assigned.
                        }
                }

                return false;
        }
};

SessionComponentCache::Pointer
SessionBuilder::
BuildComponent (ComponentSetup* pComponentSetup, SessionComponentCache* pParentComponentCache)
{
  if (!pComponentSetup) throwStaticExceptionMacro("Passed component setup is NULL.");

  GenericComponentController* pController = NULL;

        if (!pComponentSetup->ControllerIsAssigned())
  { 
                if (pParentComponentCache)
                { // there is a parent and so maybe requirements so check
      if (CheckComponentNecessity(pParentComponentCache,pComponentSetup->GetComponentID())) throwStaticExceptionMacro("No Controller specified for a needed component. Passed ComponentID: "<<pComponentSetup->GetComponentID());
                }
    return SessionComponentCache::New(pParentComponentCache,pComponentSetup,0,0);
  }
  else
  {
    pController = ControllerCentral::GetController(pComponentSetup->GetControllerID());
                if (!pController) throwStaticExceptionMacro("Controller not found for building. ControllerID: "<< pComponentSetup->GetControllerID());
    ControllerCentral::TriggerBuildEvent(1,"... building @ "+ pComponentSetup->GetIDPath().ToStr()+" : "+pComponentSetup->GetControllerID(), pComponentSetup);

    return pController->BuildSetup(pComponentSetup, pParentComponentCache);
  };
};

SessionInfo::Pointer
SessionBuilder::
BuildSession (Setup* pSetup)
{
  if (!pSetup) throwStaticExceptionMacro("Cannot build session; invalid setup (NULL)"); 
  try
  {
    SessionInfo::Pointer smpNewSession = SessionInfo::New(pSetup);

    // build sections
    ControllerCentral::TriggerBuildEvent(2,"Building sections of the setup",smpNewSession.GetPointer());
    Setup::SectionVector sections = pSetup->GetSections();

                unsigned int iSectionIndex = 0;

    for (Setup::SectionVector::iterator iter = sections.begin(); iter!=sections.end(); iter++, iSectionIndex++)
    {
      SessionComponentCache::Pointer smpComponentCache = BuildComponent(*iter,smpNewSession->GetSessionCache());
      if (smpComponentCache.IsNull()) throwStaticExceptionMacro("Controller was unable to build component (IDPath: "<<(*iter)->GetIDPath().ToStr()<<").");
      smpNewSession->GetSessionCache()->SubCaches().AddElement(smpComponentCache);
    }

    return smpNewSession;
  }
  catchAllNPassStaticMacro("Unknown exception, while building registration session.");
};

SessionComponentCache::Pointer
SessionBuilder::
GeneratePassiveComponentCache (ComponentSetup* pComponentSetup, SessionComponentCache* pParentComponentCache)
{
  if (!pComponentSetup) throwStaticExceptionMacro("Passed component setup is NULL.");

  GenericComponentController* pController = NULL;
  pController = ControllerCentral::GetController(pComponentSetup->GetControllerID());
  SessionComponentCache::Pointer smpCache = SessionComponentCache::New(pParentComponentCache,pComponentSetup,pController,0,true);

        for (ComponentSetupCollection::ComponentsCountType index=0; index<pComponentSetup->Components().Size(); index++)
  {
    ComponentSetup* pSubSetup = pComponentSetup->Components().GetElement(index); 
    SessionComponentCache::Pointer smpSubCache = SessionBuilder::GeneratePassiveComponentCache(pSubSetup,smpCache);

                smpCache->SubCaches().AddElement(smpSubCache);
  }

        return smpCache;
};

void
SessionBuilder::
ActualizeComponent(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo, const unsigned int& iActiveLayer)
{
  if (!pComponentCache) throwStaticExceptionMacro("Passed component setup is NULL.");

  if (!pComponentCache->ControllerIsAssigned())
  {
                if (CheckComponentNecessity(pComponentCache)) throwStaticExceptionMacro("No Controller specified for a needed component. Passed ComponentID: " << pComponentCache->GetComponentID());
  }
  else
  {
    if ((pComponentCache->Controller()->CheckComponentActualizationNecessity(pComponentCache)) ||
        (iActiveLayer==0))
       pComponentCache->Controller()->ActualizeComponent(pComponentCache, pSessionInfo, iActiveLayer);
  };
};   

void
SessionBuilder::
ActualizeSession (SessionInfo* pSessionInfo, const unsigned int& iActiveLayer)
{
  try
  {
    if (!pSessionInfo) throwStaticExceptionMacro("No valid session info is defined; null pointer passed.");

    for (unsigned int i = 0; i < pSessionInfo->GetComponentCaches().Size(); i++)
    {
      ActualizeComponent(pSessionInfo->GetComponentCaches().GetElement(i),pSessionInfo,iActiveLayer);
    }
  }
  catchAllNPassStaticMacro("Unknown exception, while actualizing components.");
};

void
SessionBuilder::
SetStatisticEntry(StatisticEntry& rStatisticEntry, SessionComponentCache* pComponentCache,
                 SessionInfo* pSessionInfo)
{
  GenericComponentController* pController = NULL;

  if (!pComponentCache) throwStaticExceptionMacro("Passed component cache is NULL.");
  if (!pSessionInfo) throwStaticExceptionMacro("Passed session info is NULL.");

  if (pComponentCache->ControllerIsAssigned())
  {
    pComponentCache->Controller()->SetStatisticEntry(rStatisticEntry,pComponentCache,pSessionInfo);
  }
  else
  {
    if (pComponentCache->ComponentIsAssigned())
    {
      std::string sComponentID = "unknown";
      if (pComponentCache->SetupIsAssigned())
      {
        sComponentID = pComponentCache->GetComponentID();
      }
      throwStaticExceptionMacro("Cannot set step statistic. No Controller specified for a present component in cache. ComponentID: " << sComponentID);
    }
  }
};

void
SessionBuilder::
LinkMediaToComponent(SessionComponentCache* pComponentCache, SessionInfo* pInfo)
{
  if (!pComponentCache) throwStaticExceptionMacro("Passed component cache is NULL.");
  if (!pComponentCache->SetupIsAssigned()) throwStaticExceptionMacro("Setup missing, cannot link media.");
  if (!pInfo) throwStaticExceptionMacro("Passed session info is NULL.");
  
  //Check own media links
  if (pComponentCache->Setup()->MediaLinks().Size()!=0)
  {
    for (unsigned int i=0; i < pComponentCache->Setup()->MediaLinks().Size(); i++)
    {
      ComponentMediaLink::Pointer pLink = pComponentCache->Setup()->MediaLinks().GetElement(i);

      ControllerCentral::TriggerBuildEvent(5,"... linking "+ pComponentCache->GetIDPath().ToStr()+ "/#" +pLink->GetMediaID() + " to " + pLink->GetSourceIDPath().ToStr(), pComponentCache);

      IDPath mediaPath = pLink->GetSourceIDPath().TransformIDPath(pComponentCache->GetIDPath());

      GenericMediaType::Pointer smpMedia = SessionAccessor::GetMedia(mediaPath,pInfo);
      
                        pComponentCache->Controller()->SetMedia(pLink->GetMediaID(),smpMedia,pComponentCache,pInfo);
    }
  }

  //Check the media links of sub caches
  for (unsigned int iSub=0; iSub<pComponentCache->SubCaches().Size(); iSub++)
  {
    LinkMediaToComponent(pComponentCache->SubCaches().GetElement(iSub),pInfo);
  }
};

void
SessionBuilder::
LinkMediaToComponentByID(const std::string& sMediaID, SessionComponentCache* pComponentCache, SessionInfo* pInfo)
{
  if (!pComponentCache) throwStaticExceptionMacro("Passed component cache is NULL.");
  if (!pComponentCache->SetupIsAssigned()) throwStaticExceptionMacro("Setup missing, cannot link media.");
  if (!pInfo) throwStaticExceptionMacro("Passed session info is NULL.");
  
  //Check own media links
  ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(sMediaID);
  if (smpLink.IsNotNull())
  {
    ControllerCentral::TriggerBuildEvent(5,"... linking "+ pComponentCache->GetIDPath().ToStr()+ "/#" +smpLink->GetMediaID() + " to " + smpLink->GetSourceIDPath().ToStr(), pComponentCache);

    IDPath mediaPath = smpLink->GetSourceIDPath().TransformIDPath(pComponentCache->GetIDPath());

    GenericMediaType::Pointer smpMedia = SessionAccessor::GetMedia(mediaPath,pInfo);
      
                pComponentCache->Controller()->SetMedia(smpLink->GetMediaID(),smpMedia,pComponentCache,pInfo);
  }
};

} //end of namspace free

---