vtkExecutive.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkExecutive.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/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 notice for more information.
 
=========================================================================*/
#ifndef vtkExecutive_h
#define vtkExecutive_h
 
#include "vtkCommonExecutionModelModule.h" // For export macro
#include "vtkObject.h"
 
class vtkAlgorithm;
class vtkAlgorithmOutput;
class vtkAlgorithmToExecutiveFriendship;
class vtkDataObject;
class vtkExecutiveInternals;
class vtkInformation;
class vtkInformationExecutivePortKey;
class vtkInformationExecutivePortVectorKey;
class vtkInformationIntegerKey;
class vtkInformationRequestKey;
class vtkInformationKeyVectorKey;
class vtkInformationVector;
 
class VTKCOMMONEXECUTIONMODEL_EXPORT vtkExecutive : public vtkObject
{
public:
  vtkTypeMacro(vtkExecutive, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkAlgorithm* GetAlgorithm();
 
  virtual vtkTypeBool ProcessRequest(
    vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo);
 
  virtual int ComputePipelineMTime(vtkInformation* request, vtkInformationVector** inInfoVec,
    vtkInformationVector* outInfoVec, int requestFromOutputPort, vtkMTimeType* mtime);
 
  virtual int UpdateInformation() { return 1; }
 
 
  virtual vtkTypeBool Update();
  virtual vtkTypeBool Update(int port);
 
 
  int GetNumberOfInputPorts();
  int GetNumberOfOutputPorts();
 
  int GetNumberOfInputConnections(int port);
 
  virtual vtkInformation* GetOutputInformation(int port);
 
  vtkInformationVector* GetOutputInformation();
 
  vtkInformation* GetInputInformation(int port, int connection);
 
  vtkInformationVector* GetInputInformation(int port);
 
  vtkInformationVector** GetInputInformation();
 
  vtkExecutive* GetInputExecutive(int port, int connection);
 
 
  virtual vtkDataObject* GetOutputData(int port);
  virtual void SetOutputData(int port, vtkDataObject*, vtkInformation* info);
  virtual void SetOutputData(int port, vtkDataObject*);
 
 
  virtual vtkDataObject* GetInputData(int port, int connection);
  virtual vtkDataObject* GetInputData(int port, int connection, vtkInformationVector** inInfoVec);
 
  void SetSharedInputInformation(vtkInformationVector** inInfoVec);
  void SetSharedOutputInformation(vtkInformationVector* outInfoVec);
 
 
  void Register(vtkObjectBase* o) override;
  void UnRegister(vtkObjectBase* o) override;
 
  static vtkInformationExecutivePortKey* PRODUCER();
 
  static vtkInformationExecutivePortVectorKey* CONSUMERS();
 
  static vtkInformationIntegerKey* FROM_OUTPUT_PORT();
 
 
  static vtkInformationIntegerKey* ALGORITHM_BEFORE_FORWARD();
  static vtkInformationIntegerKey* ALGORITHM_AFTER_FORWARD();
  static vtkInformationIntegerKey* ALGORITHM_DIRECTION();
  static vtkInformationIntegerKey* FORWARD_DIRECTION();
  static vtkInformationKeyVectorKey* KEYS_TO_COPY();
 
  enum
  {
    RequestUpstream,
    RequestDownstream
  };
  enum
  {
    BeforeForward,
    AfterForward
  };
 
  virtual int CallAlgorithm(vtkInformation* request, int direction, vtkInformationVector** inInfo,
    vtkInformationVector* outInfo);
 
protected:
  vtkExecutive();
  ~vtkExecutive() override;
 
  // Helper methods for subclasses.
  int InputPortIndexInRange(int port, const char* action);
  int OutputPortIndexInRange(int port, const char* action);
 
  // Called by methods to check for a recursive pipeline update.  A
  // request should be fulfilled without making another request.  This
  // is used to help enforce that behavior.  Returns 1 if no recursive
  // request is occurring, and 0 otherwise.  An error message is
  // produced automatically if 0 is returned.  The first argument is
  // the name of the calling method (the one that should not be
  // invoked recursively during an update).  The second argument is
  // the recursive request information object, if any.  It is used to
  // construct the error message.
  int CheckAlgorithm(const char* method, vtkInformation* request);
 
  virtual int ForwardDownstream(vtkInformation* request);
  virtual int ForwardUpstream(vtkInformation* request);
  virtual void CopyDefaultInformation(vtkInformation* request, int direction,
    vtkInformationVector** inInfo, vtkInformationVector* outInfo);
 
  // Reset the pipeline update values in the given output information object.
  virtual void ResetPipelineInformation(int port, vtkInformation*) = 0;
 
  // Bring the existence of output data objects up to date.
  virtual int UpdateDataObject() = 0;
 
  // Garbage collection support.
  void ReportReferences(vtkGarbageCollector*) override;
 
  virtual void SetAlgorithm(vtkAlgorithm* algorithm);
 
  // The algorithm managed by this executive.
  vtkAlgorithm* Algorithm;
 
  // Flag set when the algorithm is processing a request.
  int InAlgorithm;
 
  // Pointers to an outside instance of input or output information.
  // No references are held.  These are used to implement internal
  // pipelines.
  vtkInformationVector** SharedInputInformation;
  vtkInformationVector* SharedOutputInformation;
 
private:
  // Store an information object for each output port of the algorithm.
  vtkInformationVector* OutputInformation;
 
  // Internal implementation details.
  vtkExecutiveInternals* ExecutiveInternal;
 
  friend class vtkAlgorithmToExecutiveFriendship;
 
private:
  vtkExecutive(const vtkExecutive&) = delete;
  void operator=(const vtkExecutive&) = delete;
};
 
#endif