freSessionComponentCache.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: freSessionComponentCache.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 __freSessionComponentCache_h
#define __freSessionComponentCache_h

#include "freComponentSetup.h"
#include "freComponentCacheCollection.h"

#include "itkLightObject.h"

namespace FREE
{

/* forward declerations */
class DirectSessionComponentAccessor;
class ComponentControllerInterface;

typedef ComponentControllerInterface GenericComponentController;

class SessionComponentCache : public itk::LightObject
{
public:
  typedef SessionComponentCache          Self;
  typedef itk::LightObject               Superclass;
  typedef itk::SmartPointer<Self>        Pointer;
  typedef itk::SmartPointer<const Self>  ConstPointer;
  
  typedef itk::LightObject                        GenericComponentType;
  typedef itk::SmartPointer<GenericComponentType> GenericComponentPointer;

  itkTypeMacro(SessionComponentCache, LightObject);
  itkNewMacro(SessionComponentCache);
  static Pointer New(SessionComponentCache* pParentCache, ComponentSetup* pSetup,
                     const GenericComponentController* pController,
                     GenericComponentType* pComponent, bool bIsPassive = false);

  typedef ComponentCacheCollection<SessionComponentCache> ComponentCacheCollectionType;

  inline bool ControllerIsAssigned() const { return m_pComponentController!=0; };
  inline bool SetupIsAssigned() const { return m_smpComponentSetup.IsNotNull(); };

  std::string GetControllerID() const;

  const ComponentID& GetComponentID() const;

  friend class DirectSessionComponentAccessor;

  typedef std::map<std::string, GenericComponentPointer> CacheRepositoryType;

  typedef ComponentCacheCollection<SessionComponentCache> ComponentCacheCollectionType;

  inline bool ComponentIsAssigned() const { return m_smpComponent.IsNotNull(); };

  bool IsActive() const; 

  bool IsPassiveCache() const; 

  ComponentCacheCollectionType& SubCaches() { return m_SubCaches; };
  const ComponentCacheCollectionType& SubCaches() const { return m_SubCaches; };

  GenericComponentPointer Component() const;
  void SetComponent(GenericComponentType* pComponent);

  ComponentSetup* Setup() const;

  const GenericComponentController* Controller() const;

  bool HasParentCache() const;

  const SessionComponentCache* GetParentCache() const;
  SessionComponentCache* GetParentCache();

  const SessionComponentCache* GetRootCache() const;
  SessionComponentCache* GetRootCache();

  SessionComponentCache* GetCacheByIDPath(const IDPath& idPath);
  const SessionComponentCache* GetConstCacheByIDPath(const IDPath& idPath) const;

  IDPath GetIDPath() const;

  virtual SessionComponentCache& operator = (const SessionComponentCache& rSessionComponentCache);

protected:
  SessionComponentCache(SessionComponentCache* pParentCache, ComponentSetup* pSetup,
                        const GenericComponentController* pController, GenericComponentType* pComponent,
                        bool bIsPassive = false);

  SessionComponentCache();

  virtual ~SessionComponentCache();

  SessionComponentCache* m_pParent;

  ComponentSetup::Pointer m_smpComponentSetup;

  const GenericComponentController* m_pComponentController;

  ComponentCacheCollectionType m_SubCaches;

  GenericComponentPointer m_smpComponent;

  CacheRepositoryType m_Repository;

  bool m_bPassive;

private:
  SessionComponentCache( const SessionComponentCache& rSessionComponentCache );

};

  class DirectSessionComponentAccessor
  {
    public:
      static SessionComponentCache::GenericComponentType* GetComponent(const SessionComponentCache* pCache);
      static void SetComponent(SessionComponentCache::GenericComponentType* pComponent, SessionComponentCache* pCache);

      static SessionComponentCache::CacheRepositoryType& GetRepository(SessionComponentCache* pCache);
      static const SessionComponentCache::CacheRepositoryType& GetRepository(const SessionComponentCache* pCache);

      static SessionComponentCache::GenericComponentType* GetRepositoryElement(const std::string& sElementKey, const SessionComponentCache* pCache);
      static void SetRepositoryElement(const std::string& sElementKey, SessionComponentCache::GenericComponentType* pElement, SessionComponentCache* pCache);
      static void DeleteRepositoryElement(const std::string& sElementKey, SessionComponentCache* pCache);
  };

  class SessionComponentRepositoryKeys
  {
  public:
    static std::string ParameterValidity(const std::string& sParameterName);
    static std::string MediaValidity(const MediaID& id);
    static std::string Validity(const std::string& id);
  };

}//end of namespace FREE

#endif

---