Commit aa36c0f3 authored by Louis Amore's avatar Louis Amore Committed by Mathieu Westphal

Regroup XMLPTableWriter & XMLPDataWriter common features

parent 7b77935a
set(Module_SRCS
vtkXMLPDataSetWriter.cxx
vtkXMLPDataObjectWriter.cxx
vtkXMLPDataWriter.cxx
vtkXMLPImageDataWriter.cxx
vtkXMLPPolyDataWriter.cxx
......
This diff is collapsed.
/*=========================================================================
Program: Visualization Toolkit
Module: vtkXMLPDataObjectWriter.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.
=========================================================================*/
/**
* @class vtkXMLPDataObjectWriter
* @brief Write data in a parallel XML format.
*
* vtkXMLPDataWriter is the superclass for all XML parallel data object
* writers. It provides functionality needed for writing parallel
* formats, such as the selection of which writer writes the summary
* file and what range of pieces are assigned to each serial writer.
*
* @sa
* vtkXMLDataObjectWriter
*/
#ifndef vtkXMLPDataObjectWriter_h
#define vtkXMLPDataObjectWriter_h
#include "vtkIOParallelXMLModule.h" // For export macro
#include "vtkXMLWriter.h"
class vtkCallbackCommand;
class vtkMultiProcessController;
class VTKIOPARALLELXML_EXPORT vtkXMLPDataObjectWriter : public vtkXMLWriter
{
public:
vtkTypeMacro(vtkXMLPDataObjectWriter, vtkXMLWriter);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
//@{
/**
* Get/Set the number of pieces that are being written in parallel.
*/
vtkSetMacro(NumberOfPieces, int);
vtkGetMacro(NumberOfPieces, int);
//@}
//@{
/**
* Get/Set the range of pieces assigned to this writer.
*/
vtkSetMacro(StartPiece, int);
vtkGetMacro(StartPiece, int);
vtkSetMacro(EndPiece, int);
vtkGetMacro(EndPiece, int);
//@}
//@{
/**
* Get/Set the ghost level used for this writer's piece.
*/
vtkSetMacro(GhostLevel, int);
vtkGetMacro(GhostLevel, int);
//@}
//@{
/**
* Get/Set whether to use a subdirectory to store the pieces
*/
vtkSetMacro(UseSubdirectory, bool);
vtkGetMacro(UseSubdirectory, bool);
//@}
//@{
/**
* Get/Set whether the writer should write the summary file that
* refers to all of the pieces' individual files.
* This is on by default. Note that only the first process writes
* the summary file.
*/
virtual void SetWriteSummaryFile(int flag);
vtkGetMacro(WriteSummaryFile, int);
vtkBooleanMacro(WriteSummaryFile, int);
//@}
//@{
/**
* Controller used to communicate data type of blocks.
* By default, the global controller is used. If you want another
* controller to be used, set it with this.
*/
virtual void SetController(vtkMultiProcessController*);
vtkGetObjectMacro(Controller, vtkMultiProcessController);
//@}
/**
* Overridden to handle passing the CONTINUE_EXECUTING() flags to the
* executive.
*/
int ProcessRequest(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector) VTK_OVERRIDE;
protected:
vtkXMLPDataObjectWriter();
~vtkXMLPDataObjectWriter() VTK_OVERRIDE;
/**
* Override writing method from superclass.
*/
int WriteInternal() VTK_OVERRIDE;
/**
* Write data from the input dataset. Call WritePData(vtkIndent indent)
*/
int WriteData() VTK_OVERRIDE;
/**
* Write Data associated with the input dataset. It needs to be overriden by subclass
*/
virtual void WritePData(vtkIndent indent) = 0;
/**
* Write a piece of the dataset on disk. Called by WritePieceInternal().
* It needs to be overriden by subclass
*/
virtual int WritePiece(int index) = 0;
/**
* Method called by WriteInternal(). It's used for writing a piece of the dataset.
* It needs to be overriden by subclass.
*/
virtual int WritePieceInternal() = 0;
/**
* Overridden to make appropriate piece request from upstream.
*/
virtual int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector);
/**
* Collect information between ranks before writing the summary file.
* This method is called on all ranks while summary file is only written on 1
* rank (rank 0).
*/
virtual void PrepareSummaryFile();
/**
* Write the attributes of the piece at the given index
*/
virtual void WritePPieceAttributes(int index);
//@{
/**
* Methods for creating a filename for each piece in the dataset
*/
char* CreatePieceFileName(int index, const char* path = nullptr);
void SplitFileName();
//@}
/**
* Callback registered with the InternalProgressObserver.
*/
static void ProgressCallbackFunction(vtkObject*, unsigned long, void*, void*);
/**
* Valid at end of WriteInternal to indicate if we're going to continue
* execution.
*/
vtkGetMacro(ContinuingExecution, bool);
/**
* Get the current piece to write
*/
vtkGetMacro(CurrentPiece, int);
/**
* Progress callback from internal writer.
*/
virtual void ProgressCallback(vtkAlgorithm* w);
/**
* Method used to delete all written files.
*/
void DeleteFiles();
/**
* The observer to report progress from the internal writer.
*/
vtkCallbackCommand* InternalProgressObserver;
vtkMultiProcessController* Controller;
int StartPiece;
int EndPiece;
int NumberOfPieces;
int GhostLevel;
int WriteSummaryFile;
bool UseSubdirectory;
char* PathName;
char* FileNameBase;
char* FileNameExtension;
char* PieceFileNameExtension;
/**
* Flags used to keep track of which pieces were written out.
*/
unsigned char* PieceWrittenFlags;
/**
* Initializes PieceFileNameExtension.
*/
virtual void SetupPieceFileNameExtension();
private:
vtkXMLPDataObjectWriter(const vtkXMLPDataObjectWriter&) VTK_DELETE_FUNCTION;
void operator=(const vtkXMLPDataObjectWriter&) VTK_DELETE_FUNCTION;
/**
* Indicates the piece currently being written.
*/
int CurrentPiece;
/**
* Set in WriteInternal() to request continued execution from the executive to
* write more pieces.
*/
bool ContinuingExecution;
};
#endif
This diff is collapsed.
......@@ -26,162 +26,39 @@
#define vtkXMLPDataWriter_h
#include "vtkIOParallelXMLModule.h" // For export macro
#include "vtkXMLWriter.h"
#include "vtkXMLPDataObjectWriter.h"
class vtkCallbackCommand;
class vtkMultiProcessController;
class VTKIOPARALLELXML_EXPORT vtkXMLPDataWriter : public vtkXMLWriter
class VTKIOPARALLELXML_EXPORT vtkXMLPDataWriter : public vtkXMLPDataObjectWriter
{
public:
vtkTypeMacro(vtkXMLPDataWriter,vtkXMLWriter);
vtkTypeMacro(vtkXMLPDataWriter, vtkXMLPDataObjectWriter);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
//@{
/**
* Get/Set the number of pieces that are being written in parallel.
*/
vtkSetMacro(NumberOfPieces, int);
vtkGetMacro(NumberOfPieces, int);
//@}
//@{
/**
* Get/Set the range of pieces assigned to this writer.
*/
vtkSetMacro(StartPiece, int);
vtkGetMacro(StartPiece, int);
vtkSetMacro(EndPiece, int);
vtkGetMacro(EndPiece, int);
//@}
//@{
/**
* Get/Set the ghost level used for this writer's piece.
*/
vtkSetMacro(GhostLevel, int);
vtkGetMacro(GhostLevel, int);
//@}
//@{
/**
* Get/Set whether to use a subdirectory to store the pieces
*/
vtkSetMacro(UseSubdirectory, bool);
vtkGetMacro(UseSubdirectory, bool);
//@}
//@{
/**
* Get/Set whether the writer should write the summary file that
* refers to all of the pieces' individual files.
* This is on by default. Note that only the first process writes
* the summary file.
*/
virtual void SetWriteSummaryFile(int flag);
vtkGetMacro(WriteSummaryFile, int);
vtkBooleanMacro(WriteSummaryFile, int);
//@}
//@{
/**
* Controller used to communicate data type of blocks.
* By default, the global controller is used. If you want another
* controller to be used, set it with this.
*/
virtual void SetController(vtkMultiProcessController*);
vtkGetObjectMacro(Controller, vtkMultiProcessController);
//@}
/**
* Overridden to handle passing the CONTINUE_EXECUTING() flags to the
* executive.
*/
int ProcessRequest(vtkInformation* request,
vtkInformationVector** inputVector, vtkInformationVector* outputVector) VTK_OVERRIDE;
protected:
vtkXMLPDataWriter();
~vtkXMLPDataWriter() VTK_OVERRIDE;
/**
* Overridden to make appropriate piece request from upstream.
*/
virtual int RequestUpdateExtent(vtkInformation *request,
vtkInformationVector **inputVector, vtkInformationVector *outputVector);
// Override writing method from superclass.
int WriteInternal() VTK_OVERRIDE;
// Subclasses can override this method to collect information between ranks
// before writing the summary file. This method is called on all ranks while
// summary file is only written on 1 rank (rank 0).
virtual void PrepareSummaryFile();
virtual vtkXMLWriter* CreatePieceWriter(int index)=0;
void WritePrimaryElementAttributes(ostream &os, vtkIndent indent) VTK_OVERRIDE;
int WriteData() VTK_OVERRIDE;
virtual void WritePData(vtkIndent indent);
virtual void WritePPieceAttributes(int index);
char* CreatePieceFileName(int index, const char* path=nullptr);
void SplitFileName();
virtual int WritePiece(int index);
// Callback registered with the InternalProgressObserver.
static void ProgressCallbackFunction(vtkObject*, unsigned long, void*,
void*);
// Progress callback from internal writer.
virtual void ProgressCallback(vtkAlgorithm* w);
virtual vtkXMLWriter* CreatePieceWriter(int index) = 0;
int StartPiece;
int EndPiece;
int NumberOfPieces;
int GhostLevel;
int WriteSummaryFile;
bool UseSubdirectory;
virtual void WritePData(vtkIndent indent) VTK_OVERRIDE;
char* PathName;
char* FileNameBase;
char* FileNameExtension;
char* PieceFileNameExtension;
virtual int WritePieceInternal() VTK_OVERRIDE;
// The observer to report progress from the internal writer.
vtkCallbackCommand* InternalProgressObserver;
virtual int WritePiece(int index) VTK_OVERRIDE;
vtkMultiProcessController* Controller;
/**
* Valid at end of WriteInternal to indicate if we're going to continue
* execution.
*/
vtkGetMacro(ContinuingExecution, bool);
void WritePrimaryElementAttributes(ostream& os, vtkIndent indent) VTK_OVERRIDE;
private:
vtkXMLPDataWriter(const vtkXMLPDataWriter&) VTK_DELETE_FUNCTION;
void operator=(const vtkXMLPDataWriter&) VTK_DELETE_FUNCTION;
/**
* Method used to delete all written files.
*/
void DeleteFiles();
/**
* Initializes PieceFileNameExtension.
*/
void SetupPieceFileNameExtension();
// Indicates the piece currently being written.
int CurrentPiece;
// Set in WriteInternal() to request continued execution from the executive to
// write more pieces.
bool ContinuingExecution;
// Flags used to keep track of which pieces were written out.
unsigned char *PieceWrittenFlags;
void SetupPieceFileNameExtension() VTK_OVERRIDE;
};
#endif
This diff is collapsed.
......@@ -31,18 +31,19 @@
#define vtkXMLPTableWriter_h
#include "vtkIOParallelXMLModule.h" // For export macro
#include "vtkXMLWriter.h"
#include "vtkXMLPDataObjectWriter.h"
class vtkCallbackCommand;
class vtkMultiProcessController;
class vtkTable;
class vtkXMLTableWriter;
class vtkXMLPDataObjectWriter;
class VTKIOPARALLELXML_EXPORT vtkXMLPTableWriter : public vtkXMLWriter
class VTKIOPARALLELXML_EXPORT vtkXMLPTableWriter : public vtkXMLPDataObjectWriter
{
public:
static vtkXMLPTableWriter* New();
vtkTypeMacro(vtkXMLPTableWriter, vtkXMLWriter);
vtkTypeMacro(vtkXMLPTableWriter, vtkXMLPDataObjectWriter);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
/**
......@@ -55,69 +56,6 @@ public:
*/
const char* GetDefaultFileExtension() VTK_OVERRIDE;
//@{
/**
* Get/Set the number of pieces that are being written in parallel.
*/
vtkSetMacro(NumberOfPieces, int);
vtkGetMacro(NumberOfPieces, int);
//@}
//@{
/**
* Get/Set the range of pieces assigned to this writer.
*/
vtkSetMacro(StartPiece, int);
vtkGetMacro(StartPiece, int);
vtkSetMacro(EndPiece, int);
vtkGetMacro(EndPiece, int);
//@}
//@{
/**
* Get/Set the ghost level used for this writer's piece.
*/
vtkSetMacro(GhostLevel, int);
vtkGetMacro(GhostLevel, int);
//@}
//@{
/**
* Get/Set whether to use a subdirectory to store the pieces
*/
vtkSetMacro(UseSubdirectory, bool);
vtkGetMacro(UseSubdirectory, bool);
//@}
//@{
/**
* Get/Set whether the writer should write the summary file that
* refers to all of the pieces' individual files.
* This is on by default. Note that only the first process writes
* the summary file.
*/
virtual void SetWriteSummaryFile(int flag);
vtkGetMacro(WriteSummaryFile, int);
vtkBooleanMacro(WriteSummaryFile, int);
//@}
//@{
/**
* Controller used to communicate data type of blocks.
* By default, the global controller is used. If you want another
* controller to be used, set it with this.
*/
virtual void SetController(vtkMultiProcessController*);
vtkGetObjectMacro(Controller, vtkMultiProcessController);
//@}
/**
* Overridden to handle passing the CONTINUE_EXECUTING() flags to the
* executive.
*/
int ProcessRequest(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector) VTK_OVERRIDE;
protected:
vtkXMLPTableWriter();
~vtkXMLPTableWriter() VTK_OVERRIDE;
......@@ -127,103 +65,51 @@ protected:
*/
int FillInputPortInformation(int port, vtkInformation* info) VTK_OVERRIDE;
/**
* Return the type of data being actually written
*/
const char* GetDataSetName() VTK_OVERRIDE;
vtkXMLTableWriter* CreateTablePieceWriter();
vtkXMLWriter* CreatePieceWriter(int index);
void WritePData(vtkIndent indent);
/**
* Overridden to make appropriate piece request from upstream.
* Create a writer for the piece at a given index
*/
virtual int RequestUpdateExtent(vtkInformation* request, vtkInformationVector** inputVector,
vtkInformationVector* outputVector);
/**
* Override writing method from superclass.
*/
int WriteInternal() VTK_OVERRIDE;
vtkXMLWriter* CreatePieceWriter(int index);
/**
* Collect information between ranks before writing the summary file.
* This method is called on all ranks while summary file is only written on 1
* rank (rank 0).
*/
virtual void PrepareSummaryFile();
void WritePrimaryElementAttributes(ostream& os, vtkIndent indent) VTK_OVERRIDE;
int WriteData() VTK_OVERRIDE;
virtual void WritePPieceAttributes(int index);
char* CreatePieceFileName(int index, const char* path = nullptr);
void SplitFileName();
virtual int WritePiece(int index);
* Create a table writer for the actual piece. Used by
* CreatePieceWriter(int index)
*/
vtkXMLTableWriter* CreateTablePieceWriter();
/**
* Callback registered with the InternalProgressObserver.
*/
static void ProgressCallbackFunction(vtkObject*, unsigned long, void*, void*);
* Write a piece of the dataset on disk. Called by WritePieceInternal()
*/
int WritePiece(int index) VTK_OVERRIDE;
/**
* Valid at end of WriteInternal to indicate if we're going to continue
* execution.
* Method called by the superclass::WriteInternal(). Write a piece using
* WritePiece(int index).
*/
vtkGetMacro(ContinuingExecution, bool);
int WritePieceInternal() VTK_OVERRIDE;
void WritePRowData(vtkDataSetAttributes* ds, vtkIndent indent);
/**
* Progress callback from internal writer.
*/
* Write Data associated with the input dataset
*/
void WritePData(vtkIndent indent) VTK_OVERRIDE;
/**
* The observer to report progress from the internal writer.
*/
vtkCallbackCommand* InternalProgressObserver;
vtkMultiProcessController* Controller;
virtual void ProgressCallback(vtkAlgorithm* w);
int StartPiece;
int EndPiece;
int NumberOfPieces;
int GhostLevel;
int WriteSummaryFile;
bool UseSubdirectory;
char* PathName;
char* FileNameBase;
char* FileNameExtension;
char* PieceFileNameExtension;
* Write RowData. Called by WritePData(vtkIndent indent)
*/
void WritePRowData(vtkDataSetAttributes* ds, vtkIndent indent);
private:
vtkXMLPTableWriter(const vtkXMLPTableWriter&) VTK_DELETE_FUNCTION;
void operator=(const vtkXMLPTableWriter&) VTK_DELETE_FUNCTION;
/**
* Method used to delete all written files.
*/
void DeleteFiles();
/**
* Initializes PieceFileNameExtension.
*/
void SetupPieceFileNameExtension();
/**
* Indicates the piece currently being written.
*/
int CurrentPiece;
/**
* Set in WriteInternal() to request continued execution from the executive to
* write more pieces.
*/
bool ContinuingExecution;
/**
* Flags used to keep track of which pieces were written out.
*/
unsigned char* PieceWrittenFlags;
void SetupPieceFileNameExtension() VTK_OVERRIDE;
};
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment