vtkClientServerInterpreter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    vtkClientServerInterpreter.h

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html 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 vtkClientServerInterpreter_h
#define vtkClientServerInterpreter_h

#include "vtkObject.h"

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

class vtkClientServerInterpreter;
class vtkClientServerInterpreterInternals;
class vtkClientServerStream;

typedef int (*vtkClientServerCommandFunction)(vtkClientServerInterpreter*, vtkObjectBase* ptr,
  const char* method, const vtkClientServerStream& msg, vtkClientServerStream& result, void* ctx);

typedef vtkObjectBase* (*vtkClientServerNewInstanceFunction)(void* ctx);

typedef void (*vtkContextFreeFunction)(void* ctx);

struct vtkClientServerInterpreterErrorCallbackInfo
{
  // The stream containing the message causing the error.
  const vtkClientServerStream* css;

  // The message index with in the stream that caused the error.
  int message;
};

class VTKREMOTINGCLIENTSERVERSTREAM_EXPORT vtkClientServerInterpreter : public vtkObject
{
public:
  static vtkClientServerInterpreter* New();
  vtkTypeMacro(vtkClientServerInterpreter, vtkObject);
  void PrintSelf(ostream&, vtkIndent) override;


  int ProcessStream(const unsigned char* msg, size_t msgLength);
  int ProcessStream(const vtkClientServerStream& css);

  int ProcessOneMessage(const vtkClientServerStream& css, int message);

  const vtkClientServerStream* GetMessageFromID(vtkClientServerID id);

  const vtkClientServerStream& GetLastResult() const;

  vtkObjectBase* GetObjectFromID(vtkClientServerID id) { return this->GetObjectFromID(id, 0); }
  vtkObjectBase* GetObjectFromID(vtkClientServerID id, int noerror);

  vtkClientServerID GetIDFromObject(vtkObjectBase* key);


  void SetLogFile(const char* name);
  virtual void SetLogStream(ostream* ostr);
  vtkGetMacro(LogStream, ostream*);

  int NewInstance(vtkObjectBase* obj, vtkClientServerID id);

  VTK_NEWINSTANCE
  vtkObjectBase* NewInstance(const char* classname);

  int NewObserver(vtkObject* obj, const char* event, const vtkClientServerStream& css);

  void AddCommandFunction(const char* cname, vtkClientServerCommandFunction func, void* ctx = NULL,
    vtkContextFreeFunction ctx_free = NULL);

  bool HasCommandFunction(const char* cname);

  int CallCommandFunction(const char* classname, vtkObjectBase* ptr, const char* method,
    const vtkClientServerStream& msg, vtkClientServerStream& result);

  void AddNewInstanceFunction(const char* cname, vtkClientServerNewInstanceFunction f,
    void* ctx = NULL, vtkContextFreeFunction ctx_free = NULL);


  struct NewCallbackInfo
  {
    const char* Type;
    unsigned long ID;
  };

  void ClearLastResult();


  int Load(const char* moduleName);
  int Load(const char* moduleName, const char* const* optionalPaths);

  vtkClientServerID GetNextAvailableId();

protected:
  // constructor and destructor
  vtkClientServerInterpreter();
  ~vtkClientServerInterpreter() override;

  // A stream to which a log is written.
  ostream* LogStream;
  ostream* LogFileStream;

  // Internal message processing functions.
  int ProcessCommandNew(const vtkClientServerStream& css, int midx);
  int ProcessCommandInvoke(const vtkClientServerStream& css, int midx);
  int ProcessCommandDelete(const vtkClientServerStream& css, int midx);
  int ProcessCommandAssign(const vtkClientServerStream& css, int midx);

  // Expand all the id_value arguments of a message starting with the
  // given argument index.
  int ExpandMessage(
    const vtkClientServerStream& in, int inIndex, int startArgument, vtkClientServerStream& out);

  // Load a module dynamically given the full path to it.
  int LoadInternal(const char* moduleName, const char* fullPath);

private:
  // Message containing the result of the last command.
  vtkClientServerStream* LastResultMessage;

  // Internal implementation details.
  vtkClientServerInterpreterInternals* Internal;

private:
  vtkClientServerInterpreter(const vtkClientServerInterpreter&) = delete;
  void operator=(const vtkClientServerInterpreter&) = delete;
  int NextAvailableId;
};

#endif