namespace ns3 {

  PyObject *m_callback;

  PyObject *m_args;

  PythonEventImpl (PyObject *callback, PyObject *args)

  {

    m_callback = callback;

    Py_INCREF(m_callback);

    m_args = args;

    Py_INCREF(m_args);

  }

  virtual ~PythonEventImpl ()

  {

    PyGILState_STATE __py_gil_state;

    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);

    Py_DECREF(m_callback);

    Py_DECREF(m_args);

    if (PyEval_ThreadsInitialized())

      PyGILState_Release(__py_gil_state);

  }

  virtual void Notify ()

  {

    PyGILState_STATE __py_gil_state;

    __py_gil_state = (PyEval_ThreadsInitialized() ? PyGILState_Ensure() : (PyGILState_STATE) 0);

    PyObject *retval = PyObject_CallObject(m_callback, m_args);

    if (retval) {

        if (retval != Py_None) {

            PyErr_SetString(PyExc_TypeError, "event callback should return None");

            PyErr_Print();

          }

        Py_DECREF(retval);

      } else {

        PyErr_Print();

      }

    if (PyEval_ThreadsInitialized())

      PyGILState_Release(__py_gil_state);

  }

  PyObject *exc_type, *traceback;

  PyObject *py_time;

  PyObject *py_callback;

  PyObject *user_args;

  ns3::Ptr<PythonEventImpl> py_event_impl;

  PyNs3EventId *py_EventId;

  if (kwargs && PyObject_Length(kwargs) > 0) {

      PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");

      goto error;

  if (PyTuple_GET_SIZE(args) < 2) {

      PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 2 arguments");

      goto error;

  py_time = PyTuple_GET_ITEM(args, 0);

  py_callback = PyTuple_GET_ITEM(args, 1);

  if (!PyObject_IsInstance(py_time, (PyObject*) &PyNs3Time_Type)) {

      PyErr_SetString(PyExc_TypeError, "Parameter 1 should be a ns3.Time instance");

      goto error;

  if (!PyCallable_Check(py_callback)) {

      PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");

      goto error;

  user_args = PyTuple_GetSlice(args, 2, PyTuple_GET_SIZE(args));

  py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);

  Py_DECREF(user_args);

  py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);

  py_EventId->obj = new ns3::EventId(

      ns3::Simulator::Schedule(*((PyNs3Time *) py_time)->obj, py_event_impl));

  py_EventId->flags = PYBINDGEN_WRAPPER_FLAG_NONE;

  return (PyObject *) py_EventId;

  PyErr_Fetch(&exc_type, return_exception, &traceback);

  Py_XDECREF(exc_type);

  Py_XDECREF(traceback);

  return NULL;

  PyObject *exc_type, *traceback;

  PyObject *py_callback;

  PyObject *user_args;

  ns3::Ptr<PythonEventImpl> py_event_impl;

  PyNs3EventId *py_EventId;

  if (kwargs && PyObject_Length(kwargs) > 0) {

      PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");

      goto error;

  if (PyTuple_GET_SIZE(args) < 1) {

      PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");

      goto error;

  py_callback = PyTuple_GET_ITEM(args, 0);

  if (!PyCallable_Check(py_callback)) {

      PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");

      goto error;

  user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));

  py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);

  Py_DECREF(user_args);

  py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);

  py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleNow(py_event_impl));

  py_EventId->flags = PYBINDGEN_WRAPPER_FLAG_NONE;

  return (PyObject *) py_EventId;

  PyErr_Fetch(&exc_type, return_exception, &traceback);

  Py_XDECREF(exc_type);

  Py_XDECREF(traceback);

  return NULL;

  PyObject *exc_type, *traceback;

  PyObject *py_callback;

  PyObject *user_args;

  ns3::Ptr<PythonEventImpl> py_event_impl;

  PyNs3EventId *py_EventId;

  if (kwargs && PyObject_Length(kwargs) > 0) {

      PyErr_SetString(PyExc_TypeError, "keyword arguments not supported");

      goto error;

  if (PyTuple_GET_SIZE(args) < 1) {

      PyErr_SetString(PyExc_TypeError, "ns3.Simulator.Schedule needs at least 1 argument");

      goto error;

  py_callback = PyTuple_GET_ITEM(args, 0);

  if (!PyCallable_Check(py_callback)) {

      PyErr_SetString(PyExc_TypeError, "Parameter 2 should be callable");

      goto error;

  user_args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));

  py_event_impl = ns3::Create<PythonEventImpl>(py_callback, user_args);

  Py_DECREF(user_args);

  py_EventId = PyObject_New(PyNs3EventId, &PyNs3EventId_Type);

  py_EventId->obj = new ns3::EventId(ns3::Simulator::ScheduleDestroy(py_event_impl));

  py_EventId->flags = PYBINDGEN_WRAPPER_FLAG_NONE;

  return (PyObject *) py_EventId;

  PyErr_Fetch(&exc_type, return_exception, &traceback);

  Py_XDECREF(exc_type);

  Py_XDECREF(traceback);

  return NULL;

  bool ok;

  const char *name;

  Py_ssize_t name_len;

  ns3::TypeId tid;

  PyNs3TypeId *py_tid;

  const char *keywords[] = { "name", NULL};

  if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "s#", (char **) keywords, &name, &name_len)) {

      PyObject *exc_type, *traceback;

      PyErr_Fetch(&exc_type, return_exception, &traceback);

      Py_XDECREF(exc_type);

      Py_XDECREF(traceback);

      return NULL;

  ok = ns3::TypeId::LookupByNameFailSafe(std::string(name, name_len), &tid);

  if (!ok)

      PyErr_Format(PyExc_KeyError, "The ns3 type with name `%s' is not registered", name);

      return NULL;

  py_tid = PyObject_New(PyNs3TypeId, &PyNs3TypeId_Type);

  py_tid->obj = new ns3::TypeId (tid);

  PyNs3TypeId_wrapper_registry[(void *) py_tid->obj] = (PyObject *) py_tid;

  return (PyObject *) py_tid;

  PyObject *m_namespace;

  std::string m_variable;

  CommandLinePythonValueSetter (PyObject *ns, std::string const &variable) {

    Py_INCREF(ns);

    m_namespace = ns;

    m_variable = variable;

  }

  bool Parse (std::string value) {

    PyObject *pyvalue = PyString_FromStringAndSize (value.data(), value.size());

    PyObject_SetAttrString (m_namespace, (char *) m_variable.c_str(), pyvalue);

    if (PyErr_Occurred()) {

        PyErr_Print();

        return false;

      }

    return true;

  }

  virtual ~CommandLinePythonValueSetter () {

    Py_DECREF (m_namespace);

    m_namespace = NULL;

  }

  const char *name, *help, *variable = NULL;

  PyObject *py_namespace = NULL;

  const char *keywords[] = { "name", "help", "variable", "namespace", NULL};

  if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "ss|sO", (char **) keywords, &name, &help, &variable, &py_namespace)) {

      PyObject *exc_type, *traceback;

      PyErr_Fetch(&exc_type, return_exception, &traceback);

      Py_XDECREF(exc_type);

      Py_XDECREF(traceback);

      return NULL;

  if (variable == NULL) {

      variable = name;

    }

  if (py_namespace == NULL) {

      py_namespace = (PyObject *) self;

    }

  ns3::Ptr<CommandLinePythonValueSetter> setter = ns3::Create<CommandLinePythonValueSetter> (py_namespace, variable);

  self->obj->AddValue (name, help, ns3::MakeCallback (&CommandLinePythonValueSetter::Parse, setter));

  Py_INCREF(Py_None);

  return Py_None;

  const char *keywords[] = { "signal_check_frequency", NULL};

  int signal_check_frequency;

  ns3::Ptr<ns3::DefaultSimulatorImpl> defaultSim =

    ns3::DynamicCast<ns3::DefaultSimulatorImpl> (ns3::Simulator::GetImplementation ());

  if (defaultSim) {

      signal_check_frequency = 100;

      signal_check_frequency = -1;

  if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "|i", (char **) keywords, &signal_check_frequency)) {

      PyObject *exc_type, *traceback;

      PyErr_Fetch(&exc_type, return_exception, &traceback);

      Py_XDECREF(exc_type);

      Py_XDECREF(traceback);

      return NULL;

  PyThreadState *py_thread_state = NULL;

  if (signal_check_frequency == -1)

      if (PyEval_ThreadsInitialized ())

        py_thread_state = PyEval_SaveThread();

      ns3::Simulator::Run();

      if (py_thread_state)

        PyEval_RestoreThread(py_thread_state);

      while (!ns3::Simulator::IsFinished())

        {

          if (PyEval_ThreadsInitialized())

            py_thread_state = PyEval_SaveThread();

          for (int n = signal_check_frequency; n > 0 && !ns3::Simulator::IsFinished(); --n)

            {

              ns3::Simulator::RunOneEvent();

          if (py_thread_state)

            PyEval_RestoreThread(py_thread_state);

          PyErr_CheckSignals();

          if (PyErr_Occurred())

            return NULL;

  Py_INCREF(Py_None);

  return Py_None;