vtkCommunicator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkCommunicator_h
#define vtkCommunicator_h
 
#include "vtkObject.h"
#include "vtkParallelCoreModule.h" // For export macro
#include "vtkSmartPointer.h"       // needed for vtkSmartPointer.
#include <vector>                  // needed for std::vector
 
VTK_ABI_NAMESPACE_BEGIN
class vtkBoundingBox;
class vtkCharArray;
class vtkDataArray;
class vtkDataObject;
class vtkDataSet;
class vtkIdTypeArray;
class vtkImageData;
class vtkMultiBlockDataSet;
class vtkMultiProcessStream;
 
class VTKPARALLELCORE_EXPORT vtkCommunicator : public vtkObject
{
 
public:
  vtkTypeMacro(vtkCommunicator, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  virtual void SetNumberOfProcesses(int num);
  vtkGetMacro(NumberOfProcesses, int);


  vtkGetMacro(LocalProcessId, int);
 
  enum Tags
  {
    BROADCAST_TAG = 10,
    GATHER_TAG = 11,
    GATHERV_TAG = 12,
    SCATTER_TAG = 13,
    SCATTERV_TAG = 14,
    REDUCE_TAG = 15,
    BARRIER_TAG = 16,
    ALL_TO_ALLV_TAG = 17
  };
 
  enum StandardOperations
  {
    MAX_OP,
    MIN_OP,
    SUM_OP,
    PRODUCT_OP,
    LOGICAL_AND_OP,
    BITWISE_AND_OP,
    LOGICAL_OR_OP,
    BITWISE_OR_OP,
    LOGICAL_XOR_OP,
    BITWISE_XOR_OP
  };

  class Operation
  {
  public:
    virtual void Function(const void* A, void* B, vtkIdType length, int datatype) = 0;

    virtual int Commutative() = 0;
 
    virtual ~Operation() = default;
  };

  int Send(vtkDataObject* data, int remoteHandle, int tag);

  int Send(vtkDataArray* data, int remoteHandle, int tag);

  virtual int SendVoidArray(
    const void* data, vtkIdType length, int type, int remoteHandle, int tag) = 0;


  int Send(const int* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
  }
  int Send(const unsigned int* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
  }
  int Send(const short* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_SHORT, remoteHandle, tag);
  }
  int Send(const unsigned short* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_UNSIGNED_SHORT, remoteHandle, tag);
  }
  int Send(const long* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_LONG, remoteHandle, tag);
  }
  int Send(const unsigned long* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG, remoteHandle, tag);
  }
  int Send(const unsigned char* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_UNSIGNED_CHAR, remoteHandle, tag);
  }
  int Send(const char* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_CHAR, remoteHandle, tag);
  }
  int Send(const signed char* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_SIGNED_CHAR, remoteHandle, tag);
  }
  int Send(const float* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_FLOAT, remoteHandle, tag);
  }
  int Send(const double* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_DOUBLE, remoteHandle, tag);
  }
  int Send(const long long* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_LONG_LONG, remoteHandle, tag);
  }
  int Send(const unsigned long long* data, vtkIdType length, int remoteHandle, int tag)
  {
    return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
  }

 
  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);

  int Receive(vtkDataObject* data, int remoteHandle, int tag);

  vtkDataObject* ReceiveDataObject(int remoteHandle, int tag);

  int Receive(vtkDataArray* data, int remoteHandle, int tag);

  virtual int ReceiveVoidArray(
    void* data, vtkIdType maxlength, int type, int remoteHandle, int tag) = 0;


  int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
  }
  int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
  }
  int Receive(short* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_SHORT, remoteHandle, tag);
  }
  int Receive(unsigned short* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_SHORT, remoteHandle, tag);
  }
  int Receive(long* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_LONG, remoteHandle, tag);
  }
  int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle, tag);
  }
  int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle, tag);
  }
  int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
  }
  int Receive(signed char* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_SIGNED_CHAR, remoteHandle, tag);
  }
  int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
  }
  int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
  }
  int Receive(long long* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_LONG_LONG, remoteHandle, tag);
  }
  int Receive(unsigned long long* data, vtkIdType maxlength, int remoteHandle, int tag)
  {
    return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
  }

 
  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);


  vtkGetMacro(Count, vtkIdType);
 
  //---------------------- Collective Operations ----------------------

  virtual int AllToAllVVoidArray(const void* sendBuffer, const int* sendCounts,
    const int* sendOffsets, void* recvBuffer, const int* recvCounts, const int* recvOffsets,
    int type);

  virtual void Barrier();


  int Broadcast(int* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
  }
  int Broadcast(unsigned int* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
  }
  int Broadcast(short* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_SHORT, srcProcessId);
  }
  int Broadcast(unsigned short* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_SHORT, srcProcessId);
  }
  int Broadcast(long* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_LONG, srcProcessId);
  }
  int Broadcast(unsigned long* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG, srcProcessId);
  }
  int Broadcast(unsigned char* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_CHAR, srcProcessId);
  }
  int Broadcast(char* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
  }
  int Broadcast(signed char* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_SIGNED_CHAR, srcProcessId);
  }
  int Broadcast(float* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
  }
  int Broadcast(double* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
  }
  int Broadcast(long long* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_LONG_LONG, srcProcessId);
  }
  int Broadcast(unsigned long long* data, vtkIdType length, int srcProcessId)
  {
    return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
  }
  int Broadcast(vtkDataObject* data, int srcProcessId);
  int Broadcast(vtkDataArray* data, int srcProcessId);
 
  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);


  int Gather(const int* sendBuffer, int* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT, destProcessId);
  }
  int Gather(
    const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, destProcessId);
  }
  int Gather(const short* sendBuffer, short* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, destProcessId);
  }
  int Gather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, destProcessId);
  }
  int Gather(const long* sendBuffer, long* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG, destProcessId);
  }
  int Gather(
    const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, destProcessId);
  }
  int Gather(
    const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, destProcessId);
  }
  int Gather(const char* sendBuffer, char* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, destProcessId);
  }
  int Gather(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, destProcessId);
  }
  int Gather(const float* sendBuffer, float* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, destProcessId);
  }
  int Gather(const double* sendBuffer, double* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, destProcessId);
  }
  int Gather(
    const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, destProcessId);
  }
  int Gather(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
    int destProcessId)
  {
    return this->GatherVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, destProcessId);
  }
  int Gather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId);

  int Gather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer,
    int destProcessId);

  int Gather(const vtkMultiProcessStream& sendBuffer,
    std::vector<vtkMultiProcessStream>& recvBuffer, int destProcessId);


  int GatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength, vtkIdType* recvLengths,
    vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_INT, destProcessId);
  }
  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_INT, destProcessId);
  }
  int GatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_SHORT, destProcessId);
  }
  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_SHORT, destProcessId);
  }
  int GatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG, destProcessId);
  }
  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_LONG, destProcessId);
  }
  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_CHAR, destProcessId);
  }
  int GatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_CHAR, destProcessId);
  }
  int GatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_SIGNED_CHAR, destProcessId);
  }
  int GatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_FLOAT, destProcessId);
  }
  int GatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_DOUBLE, destProcessId);
  }
  int GatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG_LONG, destProcessId);
  }
  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->GatherVVoidArray(sendBuffer, recvBuffer, sendLength, recvLengths, offsets,
      VTK_UNSIGNED_LONG_LONG, destProcessId);
  }


  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdTypeArray* recvLengths,
    vtkIdTypeArray* offsets, int destProcessId);
  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId);
  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths,
    vtkIdType* offsets, int destProcessId);


  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData, int destProcessId);


  int Scatter(const int* sendBuffer, int* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_INT, srcProcessId);
  }
  int Scatter(
    const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, srcProcessId);
  }
  int Scatter(const short* sendBuffer, short* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, srcProcessId);
  }
  int Scatter(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, srcProcessId);
  }
  int Scatter(const long* sendBuffer, long* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_INT, srcProcessId);
  }
  int Scatter(
    const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, srcProcessId);
  }
  int Scatter(
    const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, srcProcessId);
  }
  int Scatter(const char* sendBuffer, char* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, srcProcessId);
  }
  int Scatter(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, srcProcessId);
  }
  int Scatter(const float* sendBuffer, float* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, srcProcessId);
  }
  int Scatter(const double* sendBuffer, double* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, srcProcessId);
  }
  int Scatter(
    const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, srcProcessId);
  }
  int Scatter(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType length, int srcProcessId)
  {
    return this->ScatterVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
  }
  int Scatter(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int srcProcessId);


  int ScatterV(const int* sendBuffer, int* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
    vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_INT, srcProcessId);
  }
  int ScatterV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_INT, srcProcessId);
  }
  int ScatterV(const short* sendBuffer, short* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_SHORT, srcProcessId);
  }
  int ScatterV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_SHORT, srcProcessId);
  }
  int ScatterV(const long* sendBuffer, long* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
    vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_LONG, srcProcessId);
  }
  int ScatterV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_LONG, srcProcessId);
  }
  int ScatterV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_CHAR, srcProcessId);
  }
  int ScatterV(const char* sendBuffer, char* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
    vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_CHAR, srcProcessId);
  }
  int ScatterV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_SIGNED_CHAR, srcProcessId);
  }
  int ScatterV(const float* sendBuffer, float* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_FLOAT, srcProcessId);
  }
  int ScatterV(const double* sendBuffer, double* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_DOUBLE, srcProcessId);
  }
  int ScatterV(const long long* sendBuffer, long long* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_LONG_LONG, srcProcessId);
  }
  int ScatterV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType* sendLengths, vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->ScatterVVoidArray(sendBuffer, recvBuffer, sendLengths, offsets, recvLength,
      VTK_UNSIGNED_LONG_LONG, srcProcessId);
  }



  int AllGather(const int* sendBuffer, int* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
  }
  int AllGather(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT);
  }
  int AllGather(const short* sendBuffer, short* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT);
  }
  int AllGather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT);
  }
  int AllGather(const long* sendBuffer, long* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG);
  }
  int AllGather(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG);
  }
  int AllGather(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR);
  }
  int AllGather(const char* sendBuffer, char* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
  }
  int AllGather(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR);
  }
  int AllGather(const float* sendBuffer, float* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
  }
  int AllGather(const double* sendBuffer, double* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
  }
  int AllGather(const long long* sendBuffer, long long* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG);
  }
  int AllGather(
    const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length)
  {
    return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG);
  }
  int AllGather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer);
  int AllGather(
    const vtkMultiProcessStream& sendBuffer, std::vector<vtkMultiProcessStream>& recvBuffer);

  int AllGather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer);


  int AllGatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_INT);
  }
  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_INT);
  }
  int AllGatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_SHORT);
  }
  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_SHORT);
  }
  int AllGatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG);
  }
  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_LONG);
  }
  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_CHAR);
  }
  int AllGatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_CHAR);
  }
  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_CHAR);
  }
  int AllGatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_FLOAT);
  }
  int AllGatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_DOUBLE);
  }
  int AllGatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG_LONG);
  }
  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->AllGatherVVoidArray(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_LONG_LONG);
  }
  int AllGatherV(
    vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths, vtkIdType* offsets);
  int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer);


  int Reduce(
    const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->ReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation, destProcessId);
  }
  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation, destProcessId);
  }
  int Reduce(
    const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_SHORT, operation, destProcessId);
  }
  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation, destProcessId);
  }
  int Reduce(
    const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_LONG, operation, destProcessId);
  }
  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation, destProcessId);
  }
  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation, destProcessId);
  }
  int Reduce(
    const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_CHAR, operation, destProcessId);
  }
  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation, destProcessId);
  }
  int Reduce(
    const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_FLOAT, operation, destProcessId);
  }
  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_DOUBLE, operation, destProcessId);
  }
  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation, destProcessId);
  }
  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
  }
  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation, int destProcessId);


  int Reduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, Operation* operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation, destProcessId);
  }
  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation, destProcessId);
  }
  int Reduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, Operation* operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_SHORT, operation, destProcessId);
  }
  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation, destProcessId);
  }
  int Reduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, Operation* operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_LONG, operation, destProcessId);
  }
  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation, destProcessId);
  }
  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation, destProcessId);
  }
  int Reduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, Operation* operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_CHAR, operation, destProcessId);
  }
  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation, destProcessId);
  }
  int Reduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, Operation* operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_FLOAT, operation, destProcessId);
  }
  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, Operation* operation,
    int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_DOUBLE, operation, destProcessId);
  }
  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation, destProcessId);
  }
  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
    Operation* operation, int destProcessId)
  {
    return this->ReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
  }
  int Reduce(
    vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, Operation* operation, int destProcessId);


  int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation);
  }
  int AllReduce(
    const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation);
  }
  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, operation);
  }
  int AllReduce(
    const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation);
  }
  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG, operation);
  }
  int AllReduce(
    const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation);
  }
  int AllReduce(
    const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation);
  }
  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, operation);
  }
  int AllReduce(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation);
  }
  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, operation);
  }
  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, operation);
  }
  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation);
  }
  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType length, int operation)
  {
    return this->AllReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation);
  }
  int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation);
  int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation);
  }
  int AllReduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
    Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation);
  }
  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, operation);
  }
  int AllReduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation);
  }
  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG, operation);
  }
  int AllReduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
    Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation);
  }
  int AllReduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
    Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation);
  }
  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, operation);
  }
  int AllReduce(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation);
  }
  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, operation);
  }
  int AllReduce(
    const double* sendBuffer, double* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, operation);
  }
  int AllReduce(
    const long long* sendBuffer, long long* recvBuffer, vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation);
  }
  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType length, Operation* operation)
  {
    return this->AllReduceVoidArray(
      sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation);
  }
  int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, Operation* operation);


  virtual int BroadcastVoidArray(void* data, vtkIdType length, int type, int srcProcessId);
  virtual int GatherVoidArray(
    const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, int destProcessId);
  virtual int GatherVVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int type, int destProcessId);
  virtual int ScatterVoidArray(
    const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, int srcProcessId);
  virtual int ScatterVVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int type, int srcProcessId);
  virtual int AllGatherVoidArray(
    const void* sendBuffer, void* recvBuffer, vtkIdType length, int type);
  virtual int AllGatherVVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int type);
  virtual int ReduceVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType length, int type,
    int operation, int destProcessId);
  virtual int ReduceVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType length, int type,
    Operation* operation, int destProcessId);
  virtual int AllReduceVoidArray(
    const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, int operation);
  virtual int AllReduceVoidArray(
    const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, Operation* operation);

  virtual bool CanProbe() { return false; }

  virtual int Probe(int vtkNotUsed(source), int vtkNotUsed(tag), int* vtkNotUsed(actualSource))
  {
    vtkErrorMacro("Probe not implemented for this controller.");
    return 0;
  }
 
  static void SetUseCopy(int useCopy);

  virtual int ComputeGlobalBounds(int processorId, int numProcesses, vtkBoundingBox* bounds,
    int* rightHasBounds = nullptr, int* leftHasBounds = nullptr, int hasBoundsTag = 288402,
    int localBoundsTag = 288403, int globalBoundsTag = 288404);


  static int GetParentProcessor(int pid);
  static int GetLeftChildProcessor(int pid);


  static int MarshalDataObject(vtkDataObject* object, vtkCharArray* buffer);
  static int UnMarshalDataObject(vtkCharArray* buffer, vtkDataObject* object);

  static vtkSmartPointer<vtkDataObject> UnMarshalDataObject(vtkCharArray* buffer);
 
protected:
  int WriteDataArray(vtkDataArray* object);
  int ReadDataArray(vtkDataArray* object);
 
  vtkCommunicator();
  ~vtkCommunicator() override;
 
  // Internal methods called by Send/Receive(vtkDataObject *... ) above.
  int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);

  int GatherV(vtkDataArray* sendArray, vtkDataArray* recvArray,
    vtkSmartPointer<vtkDataArray>* recvArrays, int destProcessId);
  int GatherVElementalDataObject(
    vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* receiveData, int destProcessId);

  int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer,
    vtkIdTypeArray* recvLengthsArray, vtkIdTypeArray* offsetsArray);
  int AllGatherV(
    vtkDataArray* sendArray, vtkDataArray* recvArray, vtkSmartPointer<vtkDataArray>* recvArrays);
 
  int ReceiveDataObject(vtkDataObject* data, int remoteHandle, int tag, int type = -1);
  int ReceiveElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
  int ReceiveMultiBlockDataSet(vtkMultiBlockDataSet* data, int remoteHandle, int tag);
 
  int MaximumNumberOfProcesses;
  int NumberOfProcesses;
 
  int LocalProcessId;
 
  static int UseCopy;
 
  vtkIdType Count;
 
private:
  vtkCommunicator(const vtkCommunicator&) = delete;
  void operator=(const vtkCommunicator&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkCommunicator_h