vtkSMProxyDefinitionManager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMProxyDefinitionManager_h
#define vtkSMProxyDefinitionManager_h
 
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSIProxyDefinitionManager.h"    // needed for enums
#include "vtkSMMessageMinimal.h"            // needed
#include "vtkSMRemoteObject.h"
#include "vtkWeakPointer.h" // needed for weak pointer.
 
class vtkSMProxyLocator;
class vtkEventForwarderCommand;
 
class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMProxyDefinitionManager : public vtkSMRemoteObject
{
public:
  static vtkSMProxyDefinitionManager* New();
  vtkTypeMacro(vtkSMProxyDefinitionManager, vtkSMRemoteObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SynchronizeDefinitions();
 
  void SetSession(vtkSMSession*) override;
 
  //***************************************************************************
  // enums re-defined from vtkSIProxyDefinitionManager for convenience.
  enum Events
  {
    ProxyDefinitionsUpdated = vtkSIProxyDefinitionManager::ProxyDefinitionsUpdated,
    CompoundProxyDefinitionsUpdated = vtkSIProxyDefinitionManager::CompoundProxyDefinitionsUpdated
  };
 
  enum
  {
    ALL_DEFINITIONS = vtkSIProxyDefinitionManager::ALL_DEFINITIONS,
    CORE_DEFINITIONS = vtkSIProxyDefinitionManager::CORE_DEFINITIONS,
    CUSTOM_DEFINITIONS = vtkSIProxyDefinitionManager::CUSTOM_DEFINITIONS
  };
 
  //***************************************************************************
  // Methods simply forwarded to the client-side vtkSIProxyDefinitionManager
  // instance.
 
 
  vtkPVXMLElement* GetProxyDefinition(const char* group, const char* name, bool throwError)
  {
    return this->ProxyDefinitionManager
      ? this->ProxyDefinitionManager->GetProxyDefinition(group, name, throwError)
      : nullptr;
  }
  vtkPVXMLElement* GetProxyDefinition(const char* group, const char* name)
  {
    return this->ProxyDefinitionManager
      ? this->ProxyDefinitionManager->GetProxyDefinition(group, name)
      : nullptr;
  }
 
  vtkPVXMLElement* GetCollapsedProxyDefinition(
    const char* group, const char* name, const char* subProxyName, bool throwError)
  {
    return this->ProxyDefinitionManager ? this->ProxyDefinitionManager->GetCollapsedProxyDefinition(
                                            group, name, subProxyName, throwError)
                                        : nullptr;
  }
 
  bool HasDefinition(const char* groupName, const char* proxyName)
  {
    return this->ProxyDefinitionManager
      ? this->ProxyDefinitionManager->HasDefinition(groupName, proxyName)
      : false;
  }
 
  void SaveCustomProxyDefinitions(vtkPVXMLElement* root)
  {
    if (this->ProxyDefinitionManager)
    {
      this->ProxyDefinitionManager->SaveCustomProxyDefinitions(root);
    }
  }
 
 
  VTK_NEWINSTANCE
  vtkPVProxyDefinitionIterator* NewIterator()
  {
    return this->ProxyDefinitionManager ? this->ProxyDefinitionManager->NewIterator() : nullptr;
  }
  VTK_NEWINSTANCE
  vtkPVProxyDefinitionIterator* NewIterator(int scope)
  {
    return this->ProxyDefinitionManager ? this->ProxyDefinitionManager->NewIterator(scope)
                                        : nullptr;
  }
 
 
  vtkPVProxyDefinitionIterator* NewSingleGroupIterator(const char* groupName)
  {
    return this->ProxyDefinitionManager
      ? this->ProxyDefinitionManager->NewSingleGroupIterator(groupName)
      : nullptr;
  }
  vtkPVProxyDefinitionIterator* NewSingleGroupIterator(const char* groupName, int scope)
  {
    return this->ProxyDefinitionManager
      ? this->ProxyDefinitionManager->NewSingleGroupIterator(groupName, scope)
      : nullptr;
  }
 
  //***************************************************************************
  // Methods that ensure that the command takes effect on all instances of
  // vtkSIProxyDefinitionManager across all processes.
 
 
  void AddCustomProxyDefinition(const char* group, const char* name, vtkPVXMLElement* top);
  void RemoveCustomProxyDefinition(const char* group, const char* name);
  void ClearCustomProxyDefinitions();
 
 
  void LoadCustomProxyDefinitions(vtkPVXMLElement* root);
  void LoadCustomProxyDefinitionsFromString(const char* xmlContent);
 
 
  bool LoadConfigurationXML(vtkPVXMLElement* root);
  bool LoadConfigurationXMLFromString(const char* xmlContent);
 
  void LoadState(const vtkSMMessage* msg, vtkSMProxyLocator* locator) override;
 
protected:
  vtkSMProxyDefinitionManager();
  ~vtkSMProxyDefinitionManager() override;
 
  vtkEventForwarderCommand* Forwarder;
  vtkWeakPointer<vtkSIProxyDefinitionManager> ProxyDefinitionManager;
 
private:
  vtkSMProxyDefinitionManager(const vtkSMProxyDefinitionManager&) = delete;
  void operator=(const vtkSMProxyDefinitionManager&) = delete;
};
 
#endif