// python wrapper for vtkSMPTools
//
#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include "vtkPythonArgs.h"
#include "vtkPythonOverload.h"
#include "vtkConfigure.h"
#include <cstddef>
#include <sstream>
#include "vtkVariant.h"
#include "vtkSMPTools.h"

extern "C" { VTK_ABI_EXPORT void PyVTKAddFile_vtkSMPTools(PyObject *); }

static const char *PyvtkSMPTools_Doc =
  "vtkSMPTools - A set of parallel (multi-threaded) utility functions.\n\n"
  "vtkSMPTools provides a set of utility functions that can be used to\n"
  "parallelize parts of VTK code using multiple threads. There are\n"
  "several back-end implementations of parallel functionality (currently\n"
  "Sequential, TBB and X-Kaapi) that actual execution is delegated to.\n\n"
  "vtkSMPTools()\n"
  "vtkSMPTools(const &vtkSMPTools)\n";


static PyObject *
PyvtkSMPTools_Initialize(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "Initialize");

  int temp0 = 0;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(0, 1) &&
      (ap.NoArgsLeft() || ap.GetValue(temp0)))
  {
    vtkSMPTools::Initialize(temp0);

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildNone();
    }
  }

  return result;
}


static PyObject *
PyvtkSMPTools_GetEstimatedNumberOfThreads(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "GetEstimatedNumberOfThreads");

  PyObject *result = nullptr;

  if (ap.CheckArgCount(0))
  {
    int tempr = vtkSMPTools::GetEstimatedNumberOfThreads();

    if (!ap.ErrorOccurred())
    {
      result = ap.BuildValue(tempr);
    }
  }

  return result;
}

static PyMethodDef PyvtkSMPTools_Methods[] = {
  {"Initialize", PyvtkSMPTools_Initialize, METH_VARARGS,
   "V.Initialize(int)\nC++: static void Initialize(int numThreads=0)\n\nInitialize the underlying libraries for execution. This is not\nrequired as it is automatically called before the first execution\nof any parallel code. However, it can be used to control the\nmaximum number of threads used when the back-end supports it\n(currently Simple and TBB only). Make sure to call it before any\nother parallel operation. When using Kaapi, use the\nKAAPI_CPUCOUNT env. variable to control the number of threads\nused in the thread pool.\n"},
  {"GetEstimatedNumberOfThreads", PyvtkSMPTools_GetEstimatedNumberOfThreads, METH_VARARGS,
   "V.GetEstimatedNumberOfThreads() -> int\nC++: static int GetEstimatedNumberOfThreads()\n\nGet the estimated number of threads being used by the backend.\nThis should be used as just an estimate since the number of\nthreads may vary dynamically and a particular task may not be\nexecuted on all the available threads.\n"},
  {nullptr, nullptr, 0, nullptr}
};


static PyObject *
PyvtkSMPTools_vtkSMPTools_s1(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "vtkSMPTools");

  PyObject *result = nullptr;

  if (ap.CheckArgCount(0))
  {
    vtkSMPTools *op = new vtkSMPTools();

    result = PyVTKSpecialObject_New("vtkSMPTools", op);
  }

  return result;
}

static PyObject *
PyvtkSMPTools_vtkSMPTools_s2(PyObject *, PyObject *args)
{
  vtkPythonArgs ap(args, "vtkSMPTools");

  vtkSMPTools *temp0 = nullptr;
  PyObject *pobj0 = nullptr;
  PyObject *result = nullptr;

  if (ap.CheckArgCount(1) &&
      ap.GetSpecialObject(temp0, pobj0, "vtkSMPTools"))
  {
    vtkSMPTools *op = new vtkSMPTools(*temp0);

    result = PyVTKSpecialObject_New("vtkSMPTools", op);
  }

  Py_XDECREF(pobj0);

  return result;
}

static PyMethodDef PyvtkSMPTools_vtkSMPTools_Methods[] = {
  {nullptr, PyvtkSMPTools_vtkSMPTools_s2, METH_VARARGS,
   "@W vtkSMPTools"},
  {nullptr, nullptr, 0, nullptr}
};

static PyObject *
PyvtkSMPTools_vtkSMPTools(PyObject *self, PyObject *args)
{
  int nargs = vtkPythonArgs::GetArgCount(args);

  switch(nargs)
  {
    case 0:
      return PyvtkSMPTools_vtkSMPTools_s1(self, args);
    case 1:
      return PyvtkSMPTools_vtkSMPTools_s2(self, args);
  }

  vtkPythonArgs::ArgCountError(nargs, "vtkSMPTools");
  return nullptr;
}


static PyObject *
PyvtkSMPTools_New(PyTypeObject *, PyObject *args, PyObject *kwds)
{
  if (kwds && PyDict_Size(kwds))
  {
    PyErr_SetString(PyExc_TypeError,
                    "this function takes no keyword arguments");
    return nullptr;
  }

  return PyvtkSMPTools_vtkSMPTools(nullptr, args);
}

static void PyvtkSMPTools_Delete(PyObject *self)
{
  PyVTKSpecialObject *obj = (PyVTKSpecialObject *)self;
  delete static_cast<vtkSMPTools *>(obj->vtk_ptr);
  PyObject_Del(self);
}

static Py_hash_t PyvtkSMPTools_Hash(PyObject *self)
{
#if PY_VERSION_HEX >= 0x020600B2
  return PyObject_HashNotImplemented(self);
#else
  char text[256];
  sprintf(text, "unhashable type: '%s'", Py_TYPE(self)->tp_name);
  PyErr_SetString(PyExc_TypeError, text);
  return -1;
#endif
}

static PyTypeObject PyvtkSMPTools_Type = {
  PyVarObject_HEAD_INIT(&PyType_Type, 0)
  "vtkCommonCorePython.vtkSMPTools", // tp_name
  sizeof(PyVTKSpecialObject), // tp_basicsize
  0, // tp_itemsize
  PyvtkSMPTools_Delete, // tp_dealloc
  0, // tp_print
  nullptr, // tp_getattr
  nullptr, // tp_setattr
  nullptr, // tp_compare
  PyVTKSpecialObject_Repr, // tp_repr
  nullptr, // tp_as_number
  nullptr, // tp_as_sequence
  nullptr, // tp_as_mapping
  PyvtkSMPTools_Hash, // tp_hash
  nullptr, // tp_call
  nullptr, // tp_str
  PyObject_GenericGetAttr, // tp_getattro
  nullptr, // tp_setattro
  nullptr, // tp_as_buffer
  Py_TPFLAGS_DEFAULT, // tp_flags
  PyvtkSMPTools_Doc, // tp_doc
  nullptr, // tp_traverse
  nullptr, // tp_clear
  nullptr, // tp_richcompare
  0, // tp_weaklistoffset
  nullptr, // tp_iter
  nullptr, // tp_iternext
  nullptr, // tp_methods
  nullptr, // tp_members
  nullptr, // tp_getset
  nullptr, // tp_base
  nullptr, // tp_dict
  nullptr, // tp_descr_get
  nullptr, // tp_descr_set
  0, // tp_dictoffset
  nullptr, // tp_init
  nullptr, // tp_alloc
  PyvtkSMPTools_New, // tp_new
  PyObject_Del, // tp_free
  nullptr, // tp_is_gc
  nullptr, // tp_bases
  nullptr, // tp_mro
  nullptr, // tp_cache
  nullptr, // tp_subclasses
  nullptr, // tp_weaklist
  VTK_WRAP_PYTHON_SUPPRESS_UNINITIALIZED
};

static void *PyvtkSMPTools_CCopy(const void *obj)
{
  if (obj)
  {
    return new vtkSMPTools(*static_cast<const vtkSMPTools*>(obj));
  }
  return 0;
}

extern "C" { VTK_ABI_EXPORT PyObject *PyvtkSMPTools_TypeNew(); }

PyObject *PyvtkSMPTools_TypeNew()
{
  PyVTKSpecialType_Add(
    &PyvtkSMPTools_Type,
    PyvtkSMPTools_Methods,
    PyvtkSMPTools_vtkSMPTools_Methods,
    &PyvtkSMPTools_CCopy);

  PyTypeObject *pytype = &PyvtkSMPTools_Type;

  if ((pytype->tp_flags & Py_TPFLAGS_READY) != 0)
  {
    return (PyObject *)pytype;
  }

  PyType_Ready(pytype);
  return (PyObject *)pytype;
}

void PyVTKAddFile_vtkSMPTools(
  PyObject *dict)
{
  PyObject *o;
  o = PyvtkSMPTools_TypeNew();

  if (o && PyDict_SetItemString(dict, "vtkSMPTools", o) != 0)
  {
    Py_DECREF(o);
  }

}