vtkSMTrace.h

Go to the documentation of this file.

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

#include "vtkRemotingServerManagerModule.h" // needed for exports
#include "vtkSMObject.h"
#include "vtkSmartPointer.h" // needed for iVar

#include <vector> // for std::vector

class vtkSMProxy;
class vtkSmartPyObject;

class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMTrace : public vtkSMObject
{
public:
  static vtkSMTrace* New();
  vtkTypeMacro(vtkSMTrace, vtkSMObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkSMTrace* GetActiveTracer() { return vtkSMTrace::ActiveTracer.GetPointer(); }

  static vtkSMTrace* StartTrace(const char* preamble = nullptr);

  static std::string StopTrace();


  vtkSetMacro(TraceXMLDefaults, bool);
  vtkGetMacro(TraceXMLDefaults, bool);


  vtkSetMacro(LogTraceToStdout, bool);
  vtkGetMacro(LogTraceToStdout, bool);


  vtkSetMacro(FullyTraceSupplementalProxies, bool);
  vtkGetMacro(FullyTraceSupplementalProxies, bool);


  vtkSetMacro(SkipRenderingComponents, bool);
  vtkGetMacro(SkipRenderingComponents, bool);


  vtkSetMacro(FullyTraceCameraAdjustments, bool);
  vtkGetMacro(FullyTraceCameraAdjustments, bool);

  enum
  {
    RECORD_ALL_PROPERTIES = 0,
    RECORD_MODIFIED_PROPERTIES = 1,
    RECORD_USER_MODIFIED_PROPERTIES = 2,
    RECORD_ACTIVE_MODIFIED_PROPERTIES = 3
  };

  vtkSetClampMacro(
    PropertiesToTraceOnCreate, int, RECORD_ALL_PROPERTIES, RECORD_ACTIVE_MODIFIED_PROPERTIES);
  vtkGetMacro(PropertiesToTraceOnCreate, int);

  std::string GetCurrentTrace();

  static std::string GetState(vtkSMProxy* options);

  // ************** BEGIN INTERNAL *************************

  class TraceItem;
  class VTKREMOTINGSERVERMANAGER_EXPORT TraceItemArgs
  {
  public:
    TraceItemArgs();
    ~TraceItemArgs();

    // Overloads for keyword arguments.
    TraceItemArgs& arg(const char* key, vtkObject* val);
    TraceItemArgs& arg(const char* key, const char* val);
    TraceItemArgs& arg(const char* key, int val);
    TraceItemArgs& arg(const char* key, double val);
    TraceItemArgs& arg(const char* key, bool val);
    TraceItemArgs& arg(const char* key, const std::vector<int>& val);
    TraceItemArgs& arg(const char* key, const std::vector<double>& val);
    TraceItemArgs& arg(const char* key, const std::vector<std::string>& val);
    TraceItemArgs& arg(const char* key, const std::vector<vtkObject*>& val);

    // Overloads for positional arguments.
    TraceItemArgs& arg(vtkObject* val);
    TraceItemArgs& arg(const char* val);
    TraceItemArgs& arg(int val);
    TraceItemArgs& arg(double val);
    TraceItemArgs& arg(bool val);
    TraceItemArgs& arg(const std::vector<std::string>& val);

  private:
    TraceItemArgs(const TraceItemArgs&);
    void operator=(const TraceItemArgs&);

    friend class TraceItem;
    class vtkInternals;
    vtkInternals* Internals;
  };

  class VTKREMOTINGSERVERMANAGER_EXPORT TraceItem
  {
  public:
    TraceItem(const char* type);
    ~TraceItem();
    void operator=(const TraceItemArgs& arguments);

  private:
    TraceItem(const TraceItem&);
    void operator=(const TraceItem&);
    const char* Type;
    class TraceItemInternals;
    TraceItemInternals* Internals;
  };
  // ************** END INTERNAL *************************

protected:
  vtkSMTrace();
  ~vtkSMTrace() override;

  bool CheckForError();

  bool TraceXMLDefaults;
  bool LogTraceToStdout;
  int PropertiesToTraceOnCreate;
  bool FullyTraceSupplementalProxies;
  bool SkipRenderingComponents;
  bool FullyTraceCameraAdjustments;

private:
  vtkSMTrace(const vtkSMTrace&) = delete;
  void operator=(const vtkSMTrace&) = delete;

  inline static vtkSmartPointer<vtkSMTrace> ActiveTracer = nullptr;
  class vtkInternals;
  vtkInternals* Internals;

  friend class TraceItem;
  const vtkSmartPyObject& GetTraceModule() const;
  const vtkSmartPyObject& GetCreateItemFunction() const;
};

#define SM_SCOPED_TRACE_0(x, y) x##y
#define SM_SCOPED_TRACE_1(x, y) SM_SCOPED_TRACE_0(x, y)
#define SM_SCOPED_TRACE(_A_TRACE_TYPE)                                                             \
  vtkSMTrace::TraceItem SM_SCOPED_TRACE_1(_trace_item, __LINE__)(#_A_TRACE_TYPE);                  \
  SM_SCOPED_TRACE_1(_trace_item, __LINE__) = vtkSMTrace::TraceItemArgs()
#endif