itkDataObject.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkDataObject.h,v $
  Language:  C++
  Date:      $Date: 2009-02-20 19:59:26 $
  Version:   $Revision: 1.72 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.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 __itkDataObject_h
#define __itkDataObject_h

#include "itkObject.h"
#include "itkSmartPointerForwardReference.h"
#include "itkWeakPointer.h"
#include "itkExceptionObject.h"

namespace itk
{

class ProcessObject;
class DataObject;
  
/*--------------------Data Object Exceptions---------------------------*/

class ITKCommon_EXPORT DataObjectError : public ExceptionObject
{
public:
  DataObjectError();
  
  virtual ~DataObjectError() throw() {}
  
  DataObjectError(const char *file, unsigned int lineNumber);

  DataObjectError(const std::string& file, unsigned int lineNumber);

  DataObjectError(const DataObjectError &orig);

  DataObjectError& operator=( const DataObjectError& orig);

  itkTypeMacro(DataObjectError, ExceptionObject);

  void SetDataObject(DataObject *dobj);

  DataObject* GetDataObject();

protected:
  virtual void PrintSelf(std::ostream& os, Indent indent) const;
    
private:
  DataObject *m_DataObject;
};

  
class ITKCommon_EXPORT InvalidRequestedRegionError : public DataObjectError
{
public:
  InvalidRequestedRegionError();
  
  virtual ~InvalidRequestedRegionError() throw() {}

  InvalidRequestedRegionError(const char *file, unsigned int lineNumber);

  InvalidRequestedRegionError(const std::string& file, unsigned int lineNumber);

  InvalidRequestedRegionError(const InvalidRequestedRegionError &orig);

  InvalidRequestedRegionError& operator=( const InvalidRequestedRegionError& orig);

  itkTypeMacro(InvalidRequestedRegionError, DataObjectError);

protected:
  virtual void PrintSelf(std::ostream& os, Indent indent) const;
  
};


/*----------------------------Data Object--------------------------------*/  

class ITKCommon_EXPORT DataObject : public Object
{
public:
  typedef DataObject                    Self;
  typedef Object                        Superclass;
  typedef SmartPointer<Self>            Pointer;
  typedef SmartPointer<const Self>      ConstPointer;
  
  itkTypeMacro(DataObject,Object);

  void DisconnectPipeline();
  
  SmartPointerForwardReference<ProcessObject> GetSource() const;

  unsigned int GetSourceOutputIndex() const;
    
  virtual void Initialize();

  void SetReleaseDataFlag(bool flag)
    {
    m_ReleaseDataFlag = flag;
    }
  itkGetConstReferenceMacro(ReleaseDataFlag,bool);
  itkBooleanMacro(ReleaseDataFlag);
  
  static void SetGlobalReleaseDataFlag(bool val);
  static bool GetGlobalReleaseDataFlag();
  static void GlobalReleaseDataFlagOn() 
    {Self::SetGlobalReleaseDataFlag(true);}
  static void GlobalReleaseDataFlagOff() 
    {Self::SetGlobalReleaseDataFlag(false);}
  
  void ReleaseData();

  bool ShouldIReleaseData() const;

  bool GetDataReleased() const 
    {return m_DataReleased;}
  
  virtual void Update();

  virtual void UpdateOutputInformation();

  virtual void PropagateRequestedRegion();
  virtual void UpdateOutputData();
  
  virtual void ResetPipeline();

  void SetPipelineMTime(unsigned long time) 
    {m_PipelineMTime = time;}
  itkGetConstReferenceMacro(PipelineMTime,unsigned long);

  virtual unsigned long GetUpdateMTime() const;
  
  virtual void PrepareForNewData() 
    {this->Initialize();}

  void DataHasBeenGenerated();

  
  virtual void SetRequestedRegionToLargestPossibleRegion() {};

  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion()
    { return false; }

  virtual bool VerifyRequestedRegion() { return true; };

  virtual void CopyInformation(const DataObject*) {};
  
  virtual void SetRequestedRegion(DataObject *) {};
  
  virtual void Graft( const DataObject *) {};
  
protected:
  DataObject();
  ~DataObject();
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual void PropagateResetPipeline();
  
private:
  DataObject(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  mutable WeakPointer<ProcessObject> m_Source; 
  mutable unsigned int m_SourceOutputIndex;
    
  TimeStamp m_UpdateMTime;  

  bool m_ReleaseDataFlag; //Data will release after use by a filter if on
  bool m_DataReleased; //Keep track of data release during pipeline execution

  unsigned long m_PipelineMTime;

  static bool m_GlobalReleaseDataFlag;

  bool ConnectSource(ProcessObject *s, unsigned long idx) const;

  bool DisconnectSource(ProcessObject *s, unsigned long idx) const;
  
  friend class ProcessObject;
  friend class DataObjectError;
};

} // end namespace itk
  
#endif