vtkPVSessionBase.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPVSessionBase_h
#define vtkPVSessionBase_h
 
#include "vtkPVSession.h"
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSMMessageMinimal.h"            // needed for vtkSMMessage
 
class vtkClientServerStream;
class vtkCollection;
class vtkSIObject;
class vtkPVInformation;
class vtkPVServerInformation;
class vtkSIProxyDefinitionManager;
class vtkPVSessionCore;
 
class VTKREMOTINGSERVERMANAGER_EXPORT vtkPVSessionBase : public vtkPVSession
{
public:
  vtkTypeMacro(vtkPVSessionBase, vtkPVSession);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum EventIds
  {
    RegisterRemoteObjectEvent = 1234,
    UnRegisterRemoteObjectEvent = 4321,
    ProcessingRemoteEnd = 2143,
    ConnectionLost = 6789
  };
 
  //---------------------------------------------------------------------------
  // Superclass Implementations
  //---------------------------------------------------------------------------
 
  ServerFlags GetProcessRoles() override;
 
  vtkPVServerInformation* GetServerInformation() override;
 
  vtkMPIMToNSocketConnection* GetMPIMToNSocketConnection() override;
 
  //---------------------------------------------------------------------------
  // Remote communication API. This API is used for communication in the
  // CLIENT -> SERVER(s) direction.
  //---------------------------------------------------------------------------
 
  virtual void PushState(vtkSMMessage* msg);
 
  virtual void PullState(vtkSMMessage* msg);
 
  virtual void ExecuteStream(
    vtkTypeUInt32 location, const vtkClientServerStream& stream, bool ignore_errors = false);
 
  virtual const vtkClientServerStream& GetLastResult(vtkTypeUInt32 location);
 
  virtual bool GatherInformation(
    vtkTypeUInt32 location, vtkPVInformation* information, vtkTypeUInt32 globalid);
 
  //---------------------------------------------------------------------------
  // Remote communication API. This API is used for communication in the
  // SERVER -> CLIENT direction. Since satellite nodes cannot communicate with
  // the client, these methods have no effect on the satellite nodes and must
  // only the called on the root-nodes for the server processes.
  // If these methods are called on a process acting as a client, then it is
  // processed on that process immediately, as appropriate.
  //---------------------------------------------------------------------------
 
  virtual void NotifyAllClients(const vtkSMMessage*) = 0;
 
  virtual void NotifyOtherClients(const vtkSMMessage*) = 0;
 
  //---------------------------------------------------------------------------
  // API dealing with/forwarded to vtkPVSessionCore dealing with SIObjects and
  // SMObjects.
  //---------------------------------------------------------------------------
 
 
  vtkGetObjectMacro(SessionCore, vtkPVSessionCore);
 
  vtkSIProxyDefinitionManager* GetProxyDefinitionManager();
 
  vtkSIObject* GetSIObject(vtkTypeUInt32 globalid);
 
  virtual void UnRegisterSIObject(vtkSMMessage* msg);
 
  virtual void RegisterSIObject(vtkSMMessage* msg);
 
  vtkObject* GetRemoteObject(vtkTypeUInt32 globalid);
 
  virtual void GetAllRemoteObjects(vtkCollection* collection);
 
  //---------------------------------------------------------------------------
  // API for GlobalId management
  //---------------------------------------------------------------------------
 
  virtual vtkTypeUInt32 GetNextGlobalUniqueIdentifier();
 
  virtual vtkTypeUInt32 GetNextChunkGlobalUniqueIdentifier(vtkTypeUInt32 chunkSize);
 
  virtual bool IsProcessingRemoteNotification();
 
  virtual void UseSessionCoreOf(vtkPVSessionBase* other);
 
protected:
  vtkPVSessionBase();
  vtkPVSessionBase(vtkPVSessionCore* coreToUse);
  ~vtkPVSessionBase() override;
 
 
  vtkPVSessionCore* GetSessionCore() const;
  void SetSessionCore(vtkPVSessionCore*);
 
 
  void PrepareProgressInternal() override;
  void CleanupPendingProgressInternal() override;
 
  friend class vtkSMRemoteObject;
  friend class vtkSMSessionProxyManager;
  friend class vtkSMLiveInsituLinkProxy; // Needed to get access to vtkPVCatalystSessionCore
 
 
  virtual bool StartProcessingRemoteNotification();
  virtual void StopProcessingRemoteNotification(bool previousValue);
  bool ProcessingRemoteNotification;
 
  void RegisterRemoteObject(vtkTypeUInt32 globalid, vtkTypeUInt32 location, vtkObject* obj);
 
  void UnRegisterRemoteObject(vtkTypeUInt32 globalid, vtkTypeUInt32 location);
 
  vtkPVSessionCore* SessionCore;
 
private:
  vtkPVSessionBase(const vtkPVSessionBase&) = delete;
  void operator=(const vtkPVSessionBase&) = delete;
 
  // Shared constructor method
  void InitSessionBase(vtkPVSessionCore* coreToUse);
 
  vtkPVServerInformation* LocalServerInformation;
  unsigned long ActivateObserverTag;
  unsigned long DesactivateObserverTag;
};
 
#endif