itkDataObject.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkDataObject_h
#define itkDataObject_h

#include "itkObject.h"
#include "itkSmartPointerForwardReference.h"
#include "itkMacro.h"
#include "itkRealTimeStamp.h"

namespace itk
{
class ProcessObject;
class DataObject;

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

class ITKCommon_EXPORT DataObjectError:public ExceptionObject
{
public:
  DataObjectError();

  virtual ~DataObjectError()
  ITK_NOEXCEPT {}

  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()
  ITK_NOEXCEPT {}

  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 ITK_OVERRIDE;
};

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

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

  typedef std::string                DataObjectIdentifierType;

  itkTypeMacro(DataObject, Object);

  void DisconnectPipeline();

  SmartPointerForwardReference< ProcessObject > GetSource() const;

  const DataObjectIdentifierType & GetSourceOutputName() const;

  typedef std::vector< Pointer >::size_type DataObjectPointerArraySizeType;
  DataObjectPointerArraySizeType 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(ModifiedTimeType time)
  { m_PipelineMTime = time; }
  itkGetConstReferenceMacro(PipelineMTime, ModifiedTimeType);

  virtual ModifiedTimeType GetUpdateMTime() const;

  itkSetMacro( RealTimeStamp, RealTimeStamp );
  itkGetConstReferenceMacro( RealTimeStamp, RealTimeStamp );

  virtual void PrepareForNewData()
  { this->Initialize(); }

  virtual void DataHasBeenGenerated();

  virtual void SetRequestedRegionToLargestPossibleRegion() {}

  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion()
  { return false; }

  virtual bool VerifyRequestedRegion() { return true; }

  virtual void CopyInformation(const DataObject *) {}

  virtual void SetRequestedRegion(const DataObject *) {}

  virtual void Graft(const DataObject *) {}

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

  virtual void PropagateResetPipeline();

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

  WeakPointer< ProcessObject > m_Source;
  DataObjectIdentifierType                  m_SourceOutputName;

  TimeStamp m_UpdateMTime;

  RealTimeStamp m_RealTimeStamp;

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

  ModifiedTimeType m_PipelineMTime;

  static bool m_GlobalReleaseDataFlag;

  bool ConnectSource(ProcessObject *s, const DataObjectIdentifierType & name);

  bool DisconnectSource(ProcessObject *s, const DataObjectIdentifierType & name);

  friend class ProcessObject;
  friend class DataObjectError;
};
} // end namespace itk

#endif