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 "itkMacro.h"
#include "itkSingletonMacro.h"
#include "itkWeakPointer.h"
#include "itkRealTimeStamp.h"

namespace itk
{
// Forward reference because of circular dependencies
class ITK_FORWARD_EXPORT ProcessObject;
class ITK_FORWARD_EXPORT DataObject;

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

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

  ~DataObjectError() noexcept override = default;

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

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

  DataObjectError(const DataObjectError & orig) noexcept;

  DataObjectError & operator=(const DataObjectError & orig) noexcept;

  itkTypeMacro(DataObjectError, ExceptionObject);

  void SetDataObject(DataObject *dobj) noexcept;

  DataObject * GetDataObject() noexcept;

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

private:
  DataObject *m_DataObject{nullptr};
};

class ITKCommon_EXPORT InvalidRequestedRegionError:public DataObjectError
{
public:
  InvalidRequestedRegionError() noexcept;

  ~InvalidRequestedRegionError() noexcept override = default;

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

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

  InvalidRequestedRegionError(const InvalidRequestedRegionError & orig) noexcept;

  InvalidRequestedRegionError & operator=(const InvalidRequestedRegionError & orig) noexcept;

  itkTypeMacro(InvalidRequestedRegionError, DataObjectError);

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

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

class ITK_FORCE_EXPORT_MACRO(ITKCommon) DataObject:public Object
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(DataObject);

  using Self = DataObject;
  using Superclass = Object;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  using DataObjectIdentifierType = std::string;

  itkTypeMacro(DataObject, Object);

  void DisconnectPipeline();

  SmartPointer< ProcessObject > GetSource() const;

  const DataObjectIdentifierType & GetSourceOutputName() const;

  using DataObjectPointerArraySizeType = std::vector< Pointer >::size_type;
  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() override;
  void PrintSelf(std::ostream & os, Indent indent) const override;

  virtual void PropagateResetPipeline();

private:
  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);

  itkGetGlobalDeclarationMacro(bool, GlobalReleaseDataFlag);


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

#endif