vtkClientServerStream.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkClientServerStream_h
#define vtkClientServerStream_h

#include "vtkClientServerID.h" // for vtkClientServerID
#include "vtkVariant.h"        // for vtkVariant

class vtkClientServerStreamInternals;

class VTKREMOTINGCLIENTSERVERSTREAM_EXPORT vtkClientServerStream
{
public:

  vtkClientServerStream(vtkObjectBase* owner = nullptr);
  ~vtkClientServerStream();


  vtkClientServerStream(const vtkClientServerStream&, vtkObjectBase* owner = nullptr);
  vtkClientServerStream& operator=(const vtkClientServerStream&);

  enum Commands
  {
    New,
    Invoke,
    Delete,
    Assign,
    Reply,
    Error,
    EndOfCommands
  };

  enum Types
  {
    int8_value,
    int8_array,
    int16_value,
    int16_array,
    int32_value,
    int32_array,
    int64_value,
    int64_array,
    uint8_value,
    uint8_array,
    uint16_value,
    uint16_array,
    uint32_value,
    uint32_array,
    uint64_value,
    uint64_array,
    float32_value,
    float32_array,
    float64_value,
    float64_array,
    bool_value,
    string_value,
    id_value,
    vtk_object_pointer,
    stream_value,
    LastResult,
    End
  };

  void Reserve(size_t size);

  void Reset();

  void Copy(const vtkClientServerStream* source);

  //--------------------------------------------------------------------------
  // Stream reading methods:

  int GetNumberOfMessages() const;

  vtkClientServerStream::Commands GetCommand(int message) const;

  int GetNumberOfArguments(int message) const;

  vtkClientServerStream::Types GetArgumentType(int message, int argument) const;


  int GetArgument(int message, int argument, bool* value) const;
  int GetArgument(int message, int argument, signed char* value) const;
  int GetArgument(int message, int argument, char* value) const;
  int GetArgument(int message, int argument, short* value) const;
  int GetArgument(int message, int argument, int* value) const;
  int GetArgument(int message, int argument, long* value) const;
  int GetArgument(int message, int argument, unsigned char* value) const;
  int GetArgument(int message, int argument, unsigned short* value) const;
  int GetArgument(int message, int argument, unsigned int* value) const;
  int GetArgument(int message, int argument, unsigned long* value) const;
  int GetArgument(int message, int argument, float* value) const;
  int GetArgument(int message, int argument, double* value) const;
  int GetArgument(int message, int argument, long long* value) const;
  int GetArgument(int message, int argument, unsigned long long* value) const;
  int GetArgument(int message, int argument, signed char* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, char* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, short* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, int* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, long* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, unsigned char* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, unsigned short* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, unsigned int* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, unsigned long* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, float* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, double* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, long long* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, unsigned long long* value, vtkTypeUInt32 length) const;
  int GetArgument(int message, int argument, const char** value) const;
  int GetArgument(int message, int argument, char** value) const;
  int GetArgument(int message, int argument, vtkStdString* value) const;
  int GetArgument(int message, int argument, std::string* value) const;
  int GetArgument(int message, int argument, vtkClientServerStream* value) const;
  int GetArgument(int message, int argument, vtkClientServerID* value) const;
  int GetArgument(int message, int argument, vtkObjectBase** value) const;

  int GetArgument(int message, int& argument, vtkVariant* value) const;

  int GetArgumentLength(int message, int argument, vtkTypeUInt32* length) const;

  int GetArgumentObject(int message, int argument, vtkObjectBase** value, const char* type) const;


  struct Argument
  {
    const unsigned char* Data;
    size_t Size;
  };

  vtkClientServerStream::Argument GetArgument(int message, int argument) const;

  int GetData(const unsigned char** data, size_t* length) const;

  //--------------------------------------------------------------------------
  // Stream writing methods:


  struct Array
  {
    Types Type;
    vtkTypeUInt32 Length;
    vtkTypeUInt32 Size;
    const void* Data;
  };


  vtkClientServerStream& operator<<(vtkClientServerStream::Commands);
  vtkClientServerStream& operator<<(vtkClientServerStream::Types);
  vtkClientServerStream& operator<<(vtkClientServerStream::Argument);
  vtkClientServerStream& operator<<(vtkClientServerStream::Array);
  vtkClientServerStream& operator<<(const vtkClientServerStream&);
  vtkClientServerStream& operator<<(vtkClientServerID);
  vtkClientServerStream& operator<<(vtkObjectBase*);
  vtkClientServerStream& operator<<(const vtkStdString&);
  vtkClientServerStream& operator<<(const vtkVariant&);


  vtkClientServerStream& operator<<(bool value);
  vtkClientServerStream& operator<<(char value);
  vtkClientServerStream& operator<<(short value);
  vtkClientServerStream& operator<<(int value);
  vtkClientServerStream& operator<<(long value);
  vtkClientServerStream& operator<<(signed char value);
  vtkClientServerStream& operator<<(unsigned char value);
  vtkClientServerStream& operator<<(unsigned short value);
  vtkClientServerStream& operator<<(unsigned int value);
  vtkClientServerStream& operator<<(unsigned long value);
  vtkClientServerStream& operator<<(long long value);
  vtkClientServerStream& operator<<(unsigned long long value);
  vtkClientServerStream& operator<<(float value);
  vtkClientServerStream& operator<<(double value);
  vtkClientServerStream& operator<<(const char* value);


  static vtkClientServerStream::Array InsertArray(const char*, int);
  static vtkClientServerStream::Array InsertArray(const short*, int);
  static vtkClientServerStream::Array InsertArray(const int*, int);
  static vtkClientServerStream::Array InsertArray(const long*, int);
  static vtkClientServerStream::Array InsertArray(const signed char*, int);
  static vtkClientServerStream::Array InsertArray(const unsigned char*, int);
  static vtkClientServerStream::Array InsertArray(const unsigned short*, int);
  static vtkClientServerStream::Array InsertArray(const unsigned int*, int);
  static vtkClientServerStream::Array InsertArray(const unsigned long*, int);
  static vtkClientServerStream::Array InsertArray(const long long*, int);
  static vtkClientServerStream::Array InsertArray(const unsigned long long*, int);
  static vtkClientServerStream::Array InsertArray(const float*, int);
  static vtkClientServerStream::Array InsertArray(const double*, int);

  int SetData(const unsigned char* data, size_t length);

  //--------------------------------------------------------------------------
  // Utility methods:


  static const char* GetStringFromType(vtkClientServerStream::Types type);
  static const char* GetStringFromType(vtkClientServerStream::Types type, int index);

  static vtkClientServerStream::Types GetTypeFromString(const char* name);

  static const char* GetStringFromCommand(vtkClientServerStream::Commands cmd);

  static vtkClientServerStream::Commands GetCommandFromString(const char* name);


  void Print(ostream&) const;
  void Print(ostream&, vtkIndent) const;
  void PrintMessage(ostream&, int message) const;
  void PrintMessage(ostream&, int message, vtkIndent) const;
  void PrintArgument(ostream&, int message, int argument) const;
  void PrintArgument(ostream&, int message, int argument, vtkIndent) const;
  void PrintArgumentValue(ostream&, int message, int argument) const;


  const char* StreamToString() const;
  void StreamToString(ostream& os) const;

  int StreamFromString(const char* str);

protected:
  // Write arbitrary data to the stream.  Used internally.
  vtkClientServerStream& Write(const void* data, size_t length);

  // Data parsing utilities for SetData.
  int ParseData();
  unsigned char* ParseCommand(
    int order, unsigned char* data, unsigned char* begin, unsigned char* end);
  void ParseEnd();
  unsigned char* ParseType(int order, unsigned char* data, unsigned char* begin, unsigned char* end,
    vtkClientServerStream::Types* type);
  unsigned char* ParseValue(
    int order, unsigned char* data, unsigned char* end, unsigned int wordSize);
  unsigned char* ParseArray(
    int order, unsigned char* data, unsigned char* end, unsigned int wordSize);
  unsigned char* ParseString(int order, unsigned char* data, unsigned char* end);
  unsigned char* ParseStream(int order, unsigned char* data, unsigned char* end);

  // Enumeration of possible byte orderings of data in the stream.
  enum
  {
    BigEndian,
    LittleEndian
  };

  // Byte swap data in the given byte order to match the current
  // machine's byte order.
  void PerformByteSwap(
    int dataByteOrder, unsigned char* data, unsigned int numWords, unsigned int wordSize);

  // Get a pointer to the given value within the given message.
  // Returns 0 if either index is out of range.
  const unsigned char* GetValue(int message, int value) const;

  // Get the number of values in the given message.  The count
  // includes the Command and End portions of the message.  Returns 0
  // if the given index is out of range.
  int GetNumberOfValues(int message) const;

  // Internal implementation shared between PrintArgument and
  // PrintArgumentValue.
  void PrintArgumentInternal(ostream&, int message, int argument, int annotate, vtkIndent) const;

  // String writing routines.
  void StreamToString(ostream& os, vtkIndent indent) const;
  void MessageToString(ostream& os, int m) const;
  void MessageToString(ostream& os, int m, vtkIndent indent) const;
  void ArgumentToString(ostream& os, int m, int a) const;
  void ArgumentToString(ostream& os, int m, int a, vtkIndent indent) const;
  void ArgumentValueToString(ostream& os, int m, int a, vtkIndent indent) const;

  // Allow strings without null terminators to be passed into the stream.
  static vtkClientServerStream::Array InsertString(const char* begin, const char* end);

  // String reading routines.
  static vtkClientServerStream::Types GetTypeFromString(const char* begin, const char* end);
  static vtkClientServerStream::Commands GetCommandFromString(const char* begin, const char* end);

  int StreamFromStringInternal(const char* begin, const char* end);
  int AddMessageFromString(const char* begin, const char* end, const char** next);
  int AddArgumentFromString(const char* begin, const char* end, const char** next);

private:
  vtkClientServerStreamInternals* Internal;
  friend class vtkClientServerStreamInternals;
};


template <class T>
int vtkClientServerStreamGetArgumentObject(
  const vtkClientServerStream& msg, int message, int argument, T** result, const char* type)
{
  vtkObjectBase* obj;
  if (msg.GetArgumentObject(message, argument, &obj, type))
  {
    *result = reinterpret_cast<T*>(obj);
    return 1;
  }
  return 0;
}

#if defined(VTK_WRAPPING_CXX)
// Extract the given argument of the given message as a data array.
// This is for use only in generated wrappers.
template <class T>
class vtkClientServerStreamDataArg
{
public:
  // Constructor checks the argument type and length, allocates
  // memory, and extracts the data from the message.
  vtkClientServerStreamDataArg(const vtkClientServerStream& msg, int message, int argument)
    : Data(nullptr)
  {
    // Check the argument length.
    vtkTypeUInt32 length = 0;
    if (msg.GetArgumentLength(message, argument, &length) && length > 0)
    {
      // Allocate memory without throwing.
      try
      {
        this->Data = new T[length];
      }
      catch (...)
      {
      }
    }

    // Extract the data into the allocated memory.
    if (this->Data && !msg.GetArgument(message, argument, this->Data, length))
    {
      delete[] this->Data;
      this->Data = nullptr;
    }
  }

  // Destructor frees data memory.
  ~vtkClientServerStreamDataArg() { delete[] this->Data; }

  // Allow this object to be passed as if it were a pointer.
  operator T*() { return this->Data; }

private:
  T* Data;
};
#endif

#endif

// VTK-HeaderTest-Exclude: vtkClientServerStream.h