freSessionComponentCache.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: freSessionComponentCache.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 "freSessionComponentCache.h"

#include "freControllerBase.h"
#include "freSetup.h"

namespace FREE
{



SessionComponentCache::GenericComponentPointer
SessionComponentCache::
Component() const
{
  if (ControllerIsAssigned())
  { //if there is a controller the component should be returned by the controller, thus
    //the controller can react to the request (e.g. actualize the component) before it
    //is used
    GenericComponentPointer smpComponent = m_pComponentController->GetGenericComponent(this);
    return smpComponent;
  }
  return m_smpComponent;
};

void
SessionComponentCache::
SetComponent(GenericComponentType* pComponent)
{
  if (ControllerIsAssigned())
  { //if there is a controller the component should be set by the controller, thus
    //the controller can react to the new component (e.g. store a media to hard disc)
    m_pComponentController->SetGenericComponent(pComponent, this);
  }
  else m_smpComponent = pComponent;
};

bool
SessionComponentCache::
IsActive() const
{
        return m_smpComponent.IsNotNull() && (m_pComponentController!=0);
}; 

bool
SessionComponentCache::
IsPassiveCache() const
{
  return m_bPassive;
}; 

ComponentSetup*
SessionComponentCache::
Setup() const
{
  if (m_smpComponentSetup.IsNotNull()) return m_smpComponentSetup;
  
  throwExceptionMacro("Setup is not assigned.");
};

const GenericComponentController*
SessionComponentCache::
Controller() const
{
  if (m_pComponentController) return m_pComponentController;
  
  throwExceptionMacro("Controller is not assigned.");
};

std::string
SessionComponentCache::
GetControllerID() const
{
  return Controller()->ControllerID();
};

const ComponentID&
SessionComponentCache::
GetComponentID() const
{
  return Setup()->GetComponentID();
};

bool
SessionComponentCache::
HasParentCache() const
{
  return m_pParent!=NULL;
};

const SessionComponentCache*
SessionComponentCache::
GetParentCache() const
{ return m_pParent; };

SessionComponentCache*
SessionComponentCache::
GetParentCache()
{ return m_pParent; };

const SessionComponentCache*
SessionComponentCache::
GetRootCache() const
{ 
  if (m_pParent) return m_pParent->GetRootCache();
  return this;
};

SessionComponentCache*
SessionComponentCache::
GetRootCache()
{ 
  if (m_pParent) return m_pParent->GetRootCache();
  return this;
};

SessionComponentCache*
SessionComponentCache::
GetCacheByIDPath(const IDPath& idPath)
{
  //Use the const variant of the method and cast the result to non const.
  const SessionComponentCache* pConstCache = this->GetConstCacheByIDPath(idPath);

  SessionComponentCache* result = 0;

  if (pConstCache) result = const_cast<SessionComponentCache*>(pConstCache);

  return result;
};

const SessionComponentCache*
SessionComponentCache::
GetConstCacheByIDPath(const IDPath& idPath) const
{
  if (idPath.IsEmpty()) return this;

  //if not dispatch passed path
  std::string sTag;
  IDPath::PathElementType token = idPath.GetFirstComponent(sTag);

  //This is like self reference by default, hence it won't be checked in the switch statement
        //It also covers the case of media or parameters as path elements: they will be skipped while
        //searching for a component.
  IDPath nextPath = idPath.GetSubIDPath();
  const SessionComponentCache* pNext = this;

  if (idPath.IsAbsolute())
  {
    pNext = GetRootCache();
    nextPath = idPath;
    nextPath.SetAbsolute(false);
  }
  else
  {
    switch(token)
    {
    case IDPath::PTAnyDescendant: //not allowed
      throwExceptionMacro("IDPath must be well defined. No Wildcards of any kind (*, //) are allowed. IDPath: " << idPath.ToStr());
    case IDPath::PTParent: //addresses parent
      pNext = GetParentCache(); break;
    case IDPath::PTAnyChild: //not allowed
      throwExceptionMacro("IDPath must be well defined. No Wildcards of any kind (*, //) are allowed. IDPath: " << idPath.ToStr());
    case IDPath::PTComponent: //not allowed
      pNext = m_SubCaches.GetElement(sTag); break;
    case IDPath::PTNULL:
      throwExceptionMacro("IDPath is invalid, contains undefined path element . IDPath: " << idPath.ToStr());
    }
  }

        if (!pNext) return NULL;
  return pNext->GetConstCacheByIDPath(nextPath);
};

IDPath
SessionComponentCache::
GetIDPath() const
{
  try
  {
    return Setup()->GetIDPath();
  }
  catchAllNPassMacro("Error while retrieving the IDPath of the assigned setup.")
};


SessionComponentCache::
SessionComponentCache(SessionComponentCache* pParentCache, ComponentSetup* pSetup,
                      const GenericComponentController* pController, GenericComponentType* pComponent,
                      bool bIsPassive)
{
  m_smpComponent = pComponent;
  m_pParent = pParentCache;
  m_smpComponentSetup = pSetup;
  m_pComponentController = pController;
  m_bPassive = bIsPassive;
};

SessionComponentCache::
SessionComponentCache()
{
  m_smpComponent = 0;
  m_pParent = 0;
  m_smpComponentSetup = 0;
  m_pComponentController = 0;
  m_bPassive = false;
};

SessionComponentCache::Pointer
SessionComponentCache::
New(SessionComponentCache* pParentCache, ComponentSetup* pSetup, const GenericComponentController* pController, GenericComponentType* pComponent, bool bIsPassive)
{
  Pointer smartPtr;
  SessionComponentCache *rawPtr = ::itk::ObjectFactory<SessionComponentCache>::Create();
  if(rawPtr == NULL)
  {
    rawPtr = new SessionComponentCache(pParentCache,pSetup,pController,pComponent,bIsPassive);
  }
  smartPtr = rawPtr;
  rawPtr->UnRegister();
  
  return smartPtr;
};

SessionComponentCache&
SessionComponentCache::
operator = (const SessionComponentCache& rSessionComponentCache)
{
  if (this == &rSessionComponentCache) return *this;

  m_smpComponentSetup = rSessionComponentCache.Setup();
  m_pComponentController = rSessionComponentCache.Controller();
  m_SubCaches = rSessionComponentCache.SubCaches();
  m_smpComponent = rSessionComponentCache.Component();

  return *this;
};

SessionComponentCache::
~SessionComponentCache()
{
};




SessionComponentCache::GenericComponentType*
DirectSessionComponentAccessor::
GetComponent(const SessionComponentCache* pCache)
{
  if (!pCache) throwStaticExceptionMacro("Error; cannot get component, cache pointer is NULL.");

  return pCache->m_smpComponent.GetPointer();
};

void
DirectSessionComponentAccessor::
SetComponent(SessionComponentCache::GenericComponentType* pComponent, SessionComponentCache* pCache)
{
  if (!pCache) throwStaticExceptionMacro("Error; cannot get component, cache pointer is NULL.");

  pCache->m_smpComponent = pComponent;
};

SessionComponentCache::CacheRepositoryType&
DirectSessionComponentAccessor::
GetRepository(SessionComponentCache* pCache)
{
  if (!pCache) throwStaticExceptionMacro("Error; cannot return repository, cache pointer is NULL.");

  return pCache->m_Repository;
};

const SessionComponentCache::CacheRepositoryType&
DirectSessionComponentAccessor::
GetRepository(const SessionComponentCache* pCache)
{
  if (!pCache) throwStaticExceptionMacro("Error; cannot return repository, cache pointer is NULL.");

  return pCache->m_Repository;
};

SessionComponentCache::GenericComponentType*
DirectSessionComponentAccessor::
GetRepositoryElement(const std::string& sElementKey, const SessionComponentCache* pCache)
{
  if (!pCache) throwStaticExceptionMacro("Error; cannot get repository element, cache pointer is NULL.");

  SessionComponentCache::CacheRepositoryType::const_iterator pos = pCache->m_Repository.find(sElementKey);
  if (pos!=pCache->m_Repository.end()) return pos->second.GetPointer();

  return NULL;
};

void
DirectSessionComponentAccessor::
SetRepositoryElement(const std::string& sElementKey, SessionComponentCache::GenericComponentType* pElement, SessionComponentCache* pCache)
{
  if (!pCache) throwStaticExceptionMacro("Error; cannot set repository element, cache pointer is NULL.");

  typedef std::pair< std::string, SessionComponentCache::GenericComponentPointer > ValueType;
  typedef std::pair< SessionComponentCache::CacheRepositoryType::iterator, bool > PositionType;

  SessionComponentCache::GenericComponentPointer smpElement = pElement;
  PositionType pos = pCache->m_Repository.insert( ValueType(sElementKey, smpElement));

  if (pos.second == false)
  { //Key already exists so replace component
    (pos.first)->second = pElement;
  }
};

void
DirectSessionComponentAccessor::
DeleteRepositoryElement(const std::string& sElementKey, SessionComponentCache* pCache)
{
  pCache->m_Repository.erase(sElementKey);
};




std::string
SessionComponentRepositoryKeys::
ParameterValidity(const std::string& sParameterName)
{
  return "ParameterValidityTag_"+sParameterName;
};

std::string
SessionComponentRepositoryKeys::
MediaValidity(const MediaID& id)
{
  return "MediaValidityTag_"+id;
};

std::string
SessionComponentRepositoryKeys::
Validity(const std::string& id)
{
  return "ValidityTag_"+id;
};

}//end of namespace FREE

---