freMediaDrainController.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: freMediaDrainController.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 "freMediaDrainController.h"
#include "freStoreableMediaControllerBase.h"
#include "freExceptions.h"

namespace FREE
{

DefineParameterMacro(MediaDrainController,SaveAllMedia,"SaveAllMedia","Request this parameter to save all linked media that have changed. In the returning parameter every layer is associated to one stored media. Values are media ID and IDPath of the source.");


void
MediaDrainController::
SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia, ComponentType* pComponent,
               SessionComponentCache* pComponentCache,
               SessionInfo* pSessionInfo) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Passed component cache is NULL.");
  if (!pSessionInfo) throwCtrlExceptionMacro("","Passed session info is NULL.");

  SessionComponentCache::Pointer smpMediaCache = pComponentCache->SubCaches().GetElement(mediaID);
  if (smpMediaCache.IsNotNull())
  { //there is a cache with the same idea, so use the cached controller to save the passed media
    if (!smpMediaCache->IsActive()) throwCtrlExceptionMacro("","Cannot save media via drain. Responsible subcomponent is inactive. (ComponentID: "<<mediaID<<")");

    StatisticEntry* pMediaEntry = AddStatisticEntry(smpMediaCache,pSessionInfo,"MediaSave","Saving of a Media");

    try
    {
      DirectSessionComponentAccessor::SetComponent(pMedia, smpMediaCache);
      const GenericStoreableMediaController* pStorableInterface = dynamic_cast<const GenericStoreableMediaController*>(smpMediaCache->Controller());
      
      if (!pStorableInterface) throwCtrlExceptionMacro("","Cannot save media via drain. Media seems to be no descendant of StoreableMediaControllerInterface. ControllerID: "<<smpMediaCache->GetControllerID());
      
      pStorableInterface->SaveMedia(smpMediaCache);

      if (pMediaEntry)
      {
        smpMediaCache->Controller()->SetStatisticEntry(*pMediaEntry, smpMediaCache, pSessionInfo);
        pMediaEntry->CloseEntry();
      }

      //now set the component of the "drained" media controller to a dummy object
      //to free memory because the media should only be temporary
      GenericMediaType::Pointer smpDummyMedia = GenericMediaType::New();
      DirectSessionComponentAccessor::SetComponent(smpDummyMedia, smpMediaCache);
    }
    catchAllNPassMacro("Error while setting and saving media. Media ID: "<<mediaID);

    this->ActualizeMediaValidityTag(mediaID,pComponentCache);

    this->NotifyProgress(2,"Media stored. MediaID: "+mediaID,pComponentCache);
  }
  else
  {
    Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
  }
}; 

MediaDrainController::
MediaDrainController()
{
  this->UpdateControllerID(ControllerID::MediaDrainController);
  this->m_Description = "Media drain is a special version of the media bridge that is able to store media via their subcomponents.";
};


Parameter::Pointer
MediaDrainController::
GetParameter(const SessionComponentCache* pComponentCache,
             const std::string& sParameterName) const
{
        if (sParameterName == cParam_SaveAllMedia)
  {
    Parameter::Pointer smpParameter = Parameter::New(cParam_SaveAllMedia,3);

//TODO sollte geprüft werden ob nicht parameter mit allem was dranhängt auch SessionInfo übergeben bekommt, damit dieses GetParameter überhaupt möglich ist
    //entscheidung für die hinzuname der Session info, weil nicht klar ist, ob man vielleicht doch einmal allgemeine Session informationen für die GetMedia
        //etc braucht. Deshalb die schnittstelle möglichst frei halten.
    //this->SaveAllMedia(pComponentCache,pSessionInfo);

    return smpParameter;
  }

  return Superclass::GetParameter(pComponentCache, sParameterName);
};

bool
MediaDrainController::
SaveMedia(const MediaID& mediaID, SessionComponentCache* pComponentCache,
          SessionInfo* pSessionInfo) const
{
  bool result = false;

  if (!pComponentCache) throwCtrlExceptionMacro("","Error; cannot save media. Passed component cache is NULL.");
  if (!pSessionInfo) throwCtrlExceptionMacro("","Error; cannot save media. Passed session info is NULL.");

  ComponentMediaLink::Pointer pLink = pComponentCache->Setup()->MediaLinks().GetElement(mediaID);

  if (pLink.IsNull())
  {
    this->NotifyProgress(0,"No media linked; skip saving. MediaID: "+mediaID,pComponentCache);
  }
  else
  {
    ValidityTag::Pointer smpVal = this->GetMediaValidityTag(mediaID,pComponentCache);
    ValidityTag::Pointer smpValReq = this->GetMediaValidityTagRequirement(mediaID,pComponentCache);

    if (smpVal->IsOutdated(smpValReq))
    {
      this->NotifyProgress(1,"Generating media. MediaID: "+mediaID,pComponentCache);

      IDPath mediaPath = pLink->GetSourceIDPath().TransformIDPath(pComponentCache->GetIDPath());
      GenericMediaType::Pointer smpMedia = SessionAccessor::GetMedia(mediaPath,pSessionInfo);

      this->SetMedia(mediaID,smpMedia,pComponentCache,pSessionInfo);

      result = true;
    }
    else
    {
      this->NotifyProgress(0,"Media is up to date. MediaID: "+mediaID,pComponentCache);
    }
  }

  return result;
};


STLStringVector
MediaDrainController::
SaveAllMedia(SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Error; cannot save media. Passed component cache is NULL.");
  if (!pSessionInfo) throwCtrlExceptionMacro("","Error; cannot save media. Passed session info is NULL.");

  STLStringVector savedMedia;

  for (unsigned int i=0; i < pComponentCache->Setup()->MediaLinks().Size(); i++)
  { //check all media and save if needed
    ComponentMediaLink::Pointer pLink = pComponentCache->Setup()->MediaLinks().GetElement(i);

    if (this->SaveMedia(pLink->GetMediaID(),pComponentCache,pSessionInfo))
    {
      savedMedia.push_back(pLink->GetMediaID());
    }
  }

  return savedMedia;
};

void
MediaDrainController::
GenerateProfile(CtrlProfile::ControllerProfile& profile,
                             const SessionComponentCache* pComponentCache,
                             bool bRegardOldSetup) const
{
  //parameters
  profile.Parameters().AddParameter(cParam_SaveAllMedia,Parameter::PVTIDPath,cParamDsc_SaveAllMedia,3,"",-1,false,0,DAGet);

  //subcomponents = in this case the controller to save the media
  CtrlProfile::SubComponent* pSub = profile.SubComponents().AddSubComponent("MediaWriter",0);
  pSub->SetIsTemplate(true);

  //Requirements
  CtrlProfile::ProfileOption* pOption;
  pOption = profile.Requirements().AddRequirement("MediaWriter")->AddProfileOption();
  pOption->Inheritance().AddAncestor(ControllerID::StoreableMediaControllerBase);
  pOption->CheckForInheritance();

  if (bRegardOldSetup)
  {
    //search for every non templated subcomponent. They indicate a media link the drain
    //should offer if a controller is specified.
    for ( unsigned int i = 0; i < pComponentCache->Setup()->Components().Size(); i++)
    {
      ComponentSetup* pComponent = pComponentCache->Setup()->Components().GetElement(i);
      if ((!pComponent->IsTemplateBased())&&(pComponent->ControllerIsAssigned()))
      { //Add a media link profile because we have an assigned controller
              profile.MediaMap().AddMedia(pComponent->GetComponentID(),pComponent->GetControllerID(),DASet);
      }
    }
  }
};

ValidityTag::Pointer
MediaDrainController::
GetMediaValidityTag(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  return Superclass::Superclass::GetMediaValidityTag(mediaID, pComponentCache);
}; 

} //end of namespace free

---