Ejemplo n.º 1
0
static PyObject*
tp_new (PyTypeObject* type, PyObject* args, PyObject* kwds) {
    SELF self;
    soyatomsPosition* position = NULL;
    float radius = 1.0;
    soymaterialsMaterial* material = NULL;

    // Ensure no keywords were given
    if (!_PyArg_NoKeywords("soy.bodies.Sphere", kwds))
        return NULL;

    // Parse arguments
    // TODO optional position radius and material parameters
    if (!PyArg_ParseTuple(args, "")) {
        return NULL;
    }

    // inherit base type
    self = (SELF) PyType_GenericNew(type, args, kwds);
    if (!self)
      return NULL;

    // new gobject
    self->g = soy_bodies_sphere_new(position, radius, material);

    // return self
    return (PyObject*) self;
}
Ejemplo n.º 2
0
static PyObject *
Alphabet_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    Alphabet *self = (Alphabet *)PyType_GenericNew(type, args, kwds);
    self->alphabet = NULL;
    return (PyObject *)self;
}
Ejemplo n.º 3
0
static PyObject *
Net_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    Net *self = (Net *)PyType_GenericNew(type, args, kwds);
    /*I believe PyType_GenericNew zeros the memory, so all pointers are NULL, etc */
    self->batch_size = 1;
    return (PyObject *)self;
}
Ejemplo n.º 4
0
static PyObject *
StdIO_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    StdIO *self = (StdIO *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    return (PyObject *)self;
}
Ejemplo n.º 5
0
static PyObject*
tp_new (PyTypeObject *type, PyObject *args, PyObject *kwds) {
    SELF self;
    PySoy_scenes_Scene_Object*   scene;
    PySoy_bodies_Body_Object*    controlled;
    PySoy_atoms_Position_Object* dest;
    float radius, speed, granularity = -1.0f, fuzziness = -1.0f;
    int updates = FALSE, paused = FALSE;
    PyObject* bounds = Py_None;

    static char *kw[] = {"scene", "controlled", "dest", "speed", "granularity", "fuzziness", "bounds", "updates", "paused", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!ff|fOii",   kw,
                                     &PySoy_scenes_Scene_Type,      &scene,
                                     &PySoy_bodies_Body_Type,       &controlled,
                                     &PySoy_atoms_Position_Type,    &dest,
                                                                    &speed,
                                                                    &granularity,
                                                                    &fuzziness,
                                                                    &bounds,
                                                                    &updates,
                                                                    &paused))
        return NULL;

    if (fuzziness == -1.0f) {
        fuzziness = speed/10000.0f;
    } else if (fuzziness < 0.0f) {
        PyErr_SetString(PyExc_ValueError, "'fuzziness' must be a number greater than 0");
        return NULL;
    }

    self = (SELF) PyType_GenericNew(type, args, kwds);
    if (!self)
        return NULL;

    if (bounds == Py_None) {
        self->g = soy_controllers_space_navigator_new(scene->g, controlled->g, speed, fuzziness, granularity, dest->g, updates, paused);
    } else if (PySoy_atoms_Size_Check(bounds)) {
        soycontrollersgraphSpace* graph = soy_controllers_graph_space_new_with_size(scene->g, granularity, ((PySoy_atoms_Size_Object*)bounds)->g,NULL);
        self->g = soy_controllers_space_navigator_new_with_graph(scene->g, controlled->g, speed, fuzziness, (soycontrollersgraphIGraph*) graph, dest->g, updates, paused);
    } else if (PyNumber_Check(bounds)) {
        PyObject* flt = PyNumber_Float(bounds);
        if (flt == NULL) 
            return NULL;
        radius = (float)PyFloat_AsDouble(flt);
        Py_DECREF(flt);
        if (PyErr_Occurred()) { return NULL; }

        soycontrollersgraphSpace* graph = soy_controllers_graph_space_new_with_radius(scene->g, granularity, radius,NULL);
        self->g = soy_controllers_space_navigator_new_with_graph(scene->g, controlled->g, speed, fuzziness, (soycontrollersgraphIGraph*) graph, dest->g, updates, paused);
    } else {
        PyErr_SetString(PyExc_ValueError, "'bounds' must be either a number greater then 0 or a soy.atoms.Size");
        return NULL;
    }

    return (PyObject*) self;
}
Ejemplo n.º 6
0
static PyObject *
Request_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    Request *self = (Request *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->req_ptr = NULL;
    return (PyObject *)self;
}
Ejemplo n.º 7
0
extern PyObject *
Connection_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) {
  ReQLConnection *self = (ReQLConnection *)PyType_GenericNew(type, args, kwargs);

  if (self != NULL) {
    self->reql_connection = NULL;
  }

  return (PyObject *)self;
}
Ejemplo n.º 8
0
static PyObject *
DNSResolver_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    DNSResolver *self = (DNSResolver *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->channel = NULL;
    return (PyObject *)self;
}
Ejemplo n.º 9
0
static PyObject *
cbson_dbref_tp_new (PyTypeObject *self,
                    PyObject     *args,
                    PyObject     *kwargs)
{
   /*
    * TODO: Handle args and kwargs.
    */
   return PyType_GenericNew(&cbson_dbref_type, args, kwargs);
}
Ejemplo n.º 10
0
//PyObject *PyNewLowercaser_Helper(PyObject *, PyObject* args)  
PyObject *PyNewLowercaser_Helper(CSphLowercaser* aLower)
{  

	if(!aLower) return NULL;  

	csfHelper_ToLowerObject *self;
	self = (csfHelper_ToLowerObject *)PyType_GenericNew(&csfHelper_ToLowerType, NULL, NULL);
	self->m_Lower = aLower;
	return (PyObject*)self;
}  
Ejemplo n.º 11
0
/* Allocate and initialize a new `Instruction' object given the associated
 * `xed_decoded_inst_t' structure.
 */
instruction_t *new_instruction(xed_decoded_inst_t *decoded_inst,
        xed_uint64_t runtime_address)
{
    instruction_t *instruction;
    instruction = (instruction_t *)PyType_GenericNew(&type, NULL, NULL);
    instruction->decoded_inst = decoded_inst;
    instruction->inst = xed_decoded_inst_inst(decoded_inst);
    instruction->runtime_address = runtime_address;
    return instruction;
}
Ejemplo n.º 12
0
static PyObject*
tp_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
    SELF self;

    PySoy_bodies_Body_Object* py_bodyA;
    PySoy_bodies_Body_Object* py_bodyB;
    PySoy_materials_Material_Object* py_material = NULL;
    soyscenesScene* scene;
    soybodiesBody* bodyB;
    soymaterialsMaterial* material;
    static char* kw[] = {"bodyA", "bodyB", "material", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O|O!", kw,
            &PySoy_bodies_Body_Type, &py_bodyA,
            &py_bodyB,
            &PySoy_materials_Material_Type, &py_material))
        return NULL;

    // When bodyB is a Body
    if (PyObject_TypeCheck(py_bodyB, &PySoy_bodies_Body_Type)) {
        scene = py_bodyB->g->scene;
        bodyB = py_bodyB->g;
    }

    // When bodyB is a Scene
    else if (PyObject_TypeCheck(py_bodyB, &PySoy_scenes_Scene_Type)) {
        scene = ((PySoy_scenes_Scene_Object*) py_bodyB)->g;
        bodyB = NULL;
    }

    // Otherwise raise exception
    else {
        PyErr_SetString(PyExc_ValueError,
                        "Second argument must be a Body or Scene");
        return NULL;
    }

    // Ensure bodies are in the same scene
    if (py_bodyA->g->scene != scene) {
        PyErr_SetString(PyExc_ValueError, "Scene mismatch");
        return NULL;
    }

    // Grab material
    material = (py_material) ? py_material->g : NULL;

    // Inherit base type
    self = (SELF) PyType_GenericNew(type, args, NULL);
    if(!self)
        return NULL;

    // Create gobject and return
    self->g = soy_joints_fixed_new(py_bodyA->g, bodyB, material);
    return (PyObject*) self;
}
Ejemplo n.º 13
0
static PyObject*
tp_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
    SELF self;

    soyscenesScene* scene;
    PySoy_scenes_Scene_Object* pyscene;
    PySoy_bodies_Body_Object* bodyOne;
    PySoy_bodies_Body_Object* bodyTwo;
    PySoy_atoms_Position_Object* anchor;
    PySoy_atoms_Axis_Object* axis1;
    PySoy_atoms_Axis_Object* axis2;

    if (PyArg_ParseTuple(args, "O!O!O!O!O!",
                         &PySoy_bodies_Body_Type, &bodyOne,
                         &PySoy_bodies_Body_Type, &bodyTwo,
                         &PySoy_atoms_Position_Type, &anchor,
                         &PySoy_atoms_Axis_Type, &axis1,
                         &PySoy_atoms_Axis_Type, &axis2))
        scene = bodyTwo->g->scene;

    else {
        PyErr_Clear();
        if (PyArg_ParseTuple(args, "O!O!O!O!O!",
                             &PySoy_bodies_Body_Type, &bodyOne,
                             &PySoy_scenes_Scene_Type, &pyscene,
                             &PySoy_atoms_Position_Type, &anchor,
                             &PySoy_atoms_Axis_Type, &axis1,
                             &PySoy_atoms_Axis_Type, &axis2))
            scene = pyscene->g;
        else
            return NULL;
    }

    // Ensure bodies are in the same scene
    if (bodyOne->g->scene != scene) {
        PyErr_SetString(PyExc_ValueError, "Bodies must be in the same scene");
        return NULL;
    }

    self = (SELF) PyType_GenericNew(type, args, NULL);

    if(!self)
        return NULL;

    if(!bodyTwo)
        self->g = soy_joints_piston_new(bodyOne->g, NULL,
                                        anchor->g, axis1->g, axis2->g,
                                        NULL);
    else
        self->g = soy_joints_piston_new(bodyOne->g, bodyTwo->g,
                                        anchor->g, axis1->g, axis2->g,
                                        NULL);

    return (PyObject*) self;
}
Ejemplo n.º 14
0
static PyObject *
simple_new(PyObject *self, PyObject *type_object)
{
    if (!PyType_Check(type_object))
    {
        PyErr_SetString(PyExc_TypeError,
                        "simple_new argument must be a type object.");
        return NULL;
    }
    return PyType_GenericNew((PyTypeObject *)type_object, NULL, NULL);
}
static PyObject *
Channel_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    Channel *self = (Channel *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->channel = NULL;
    self->lib_initialized = False;
    return (PyObject *)self;
}
Ejemplo n.º 16
0
static PyObject *
RWLock_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    RWLock *self;

    self = (RWLock *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->initialized = False;
    return (PyObject *)self;
}
Ejemplo n.º 17
0
static PyObject *
Handle_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    Handle *self = (Handle *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->initialized = False;
    self->uv_handle = NULL;
    self->weakreflist = NULL;
    return (PyObject *)self;
}
Ejemplo n.º 18
0
static PyObject *
Barrier_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    Barrier *self;

    self = (Barrier *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->initialized = False;
    return (PyObject *)self;
}
Ejemplo n.º 19
0
static PyObject *
Condition_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    Condition *self;

    self = (Condition *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->initialized = False;
    return (PyObject *)self;
}
Ejemplo n.º 20
0
static PyObject *
Semaphore_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
    Semaphore *self;

    self = (Semaphore *)PyType_GenericNew(type, args, kwargs);
    if (!self) {
        return NULL;
    }
    self->initialized = False;
    return (PyObject *)self;
}
static PyObject *__new__(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
	pylal_COMPLEX16FrequencySeries *obj;
	LIGOTimeGPS zero = {0, 0};

	obj = (pylal_COMPLEX16FrequencySeries *) PyType_GenericNew(type, args, kwds);
	if(!obj)
		return NULL;
	obj->series = XLALCreateCOMPLEX16FrequencySeries(NULL, &zero, 0.0, 0.0, &lalDimensionlessUnit, 0);
	obj->owner = NULL;
	return (PyObject *) obj;
}
Ejemplo n.º 22
0
static PyObject *
pymongoc_client_pool_tp_new (PyTypeObject *self,
                             PyObject     *args,
                             PyObject     *kwargs)
{
   pymongoc_client_pool_t *pyclient_pool;
   mongoc_uri_t *uri;
   const char *uri_str;
   PyObject *key = NULL;
   PyObject *pyuri = NULL;
   PyObject *ret = NULL;

   if (kwargs) {
      key = PyString_FromStringAndSize("uri", 3);
      if (PyDict_Contains(kwargs, key)) {
         if (!(pyuri = PyDict_GetItem(kwargs, key))) {
            goto cleanup;
         } else if (!PyString_Check(pyuri)) {
            PyErr_SetString(PyExc_TypeError, "uri must be a string.");
            goto cleanup;
         }
      }
   }

   uri_str = pyuri ? PyString_AsString(pyuri) : NULL;
   uri = mongoc_uri_new (uri_str);

   pyclient_pool = (pymongoc_client_pool_t *)
      PyType_GenericNew (&pymongoc_client_pool_type, NULL, NULL);
   if (!pyclient_pool) {
      goto cleanup;
   }

   pyclient_pool->client_pool = mongoc_client_pool_new (uri);
   if (!pyclient_pool->client_pool) {
      PyErr_SetString (PyExc_TypeError, "Invalid URI string.");
      Py_DECREF (pyclient_pool);
      pyclient_pool = NULL;
      goto cleanup;
   }

   ret = (PyObject *)pyclient_pool;

cleanup:
   if (uri) {
      mongoc_uri_destroy (uri);
   }
   Py_XDECREF (key);
   Py_XDECREF (pyuri);

   return ret;
}
Ejemplo n.º 23
0
PyObject *PyNewDocument_Helper( CSphSource* pSource)
{
	if(!pSource) return NULL;  
	
	CSphSource_Python* pPySource = dynamic_cast<CSphSource_Python*>(pSource);
	if(!pPySource) return NULL;  

	
	csfHelper_DocumentObject *self;
	self = (csfHelper_DocumentObject *)PyType_GenericNew(&csfHelper_DocumentType, NULL, NULL);
	self->m_Document = pPySource;
	return (PyObject*)self;
}
Ejemplo n.º 24
0
static PyObject *
RdkHandle_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyObject *self = PyType_GenericNew(type, args, kwds);
    if (self) {
        int res = pthread_rwlock_init(&((RdkHandle *)self)->rwlock, NULL);
        if (res) {
            Py_DECREF(self);
            return set_pykafka_error("RdKafkaException", "Failed rwlock init");
        }
    }
    return self;
}
Ejemplo n.º 25
0
static SELF
tp_new (PyTypeObject* type, PyObject* args, PyObject* kwds) {
    SELF self;

    // inherit base type
    self = (SELF) PyType_GenericNew(type, args, kwds);
    if (!self)
      return NULL;

    // new gobject
    self->g = soy_widgets_window_new();

    return self;
}
Ejemplo n.º 26
0
/**
 * \ingroup python_interface_vertexseq
 * \brief Allocate a new vertex sequence object for a given graph
 * \return the allocated PyObject
 */
PyObject* igraphmodule_VertexSeq_new(PyTypeObject *subtype,
  PyObject *args, PyObject *kwds) {
  igraphmodule_VertexSeqObject *o;

  o=(igraphmodule_VertexSeqObject*)PyType_GenericNew(subtype, args, kwds);
  if (o == NULL) return NULL;

  igraph_vs_all(&o->vs);
  o->gref=0;
  o->weakreflist=0;

  RC_ALLOC("VertexSeq", o);

  return (PyObject*)o;
}
Ejemplo n.º 27
0
/**
 * \ingroup python_interface_edgeseq
 * \brief Allocate a new edge sequence object for a given graph
 * \param g the graph object being referenced
 * \return the allocated PyObject
 */
PyObject* igraphmodule_EdgeSeq_new(PyTypeObject *subtype,
	PyObject *args, PyObject *kwds) {
  igraphmodule_EdgeSeqObject* o;
  
  o=(igraphmodule_EdgeSeqObject*)PyType_GenericNew(subtype, args, kwds);
  if (o == NULL) return NULL;

  igraph_es_all(&o->es, IGRAPH_EDGEORDER_ID);
  o->gref=0;
  o->weakreflist=0;

  RC_ALLOC("EdgeSeq", o);
  
  return (PyObject*)o;
}
Ejemplo n.º 28
0
// Create a bound signal.
PyObject *qpycore_pyqtBoundSignal_New(qpycore_pyqtSignal *unbound_signal,
        PyObject *bound_pyobject, QObject *bound_qobject)
{
    qpycore_pyqtBoundSignal *bs = (qpycore_pyqtBoundSignal *)PyType_GenericNew(&qpycore_pyqtBoundSignal_Type, 0, 0);

    if (bs)
    {
        Py_INCREF((PyObject *)unbound_signal);
        bs->unbound_signal = unbound_signal;

        bs->bound_pyobject = bound_pyobject;
        bs->bound_qobject = bound_qobject;
    }

    return (PyObject *)bs;
}
Ejemplo n.º 29
0
static PyObject *
ec_new_for_custom_dealloc(PyTypeObject *type, PyObject *args, PyObject *kw)
{
  /* This is for EC's that have deallocs.  For these, we need to
     incref the type when we create an instance, because the deallocs
     will decref the type.
  */

  PyObject *r;

  r = PyType_GenericNew(type, args, kw);
  if (r)
    {
      Py_INCREF(type);
    }
  return r;
}
Ejemplo n.º 30
0
Archivo: Joint.c Proyecto: RONNCC/pysoy
static PyObject*
tp_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
    SELF self;

    soyscenesScene* scene;
    PySoy_scenes_Scene_Object* pyscene;
    PySoy_bodies_Body_Object* bodyOne;
    PySoy_bodies_Body_Object* bodyTwo;

    // ensure no keywords were given
    if (!_PyArg_NoKeywords("soy.joints.Joint", kwds))
        return NULL;

    if (PyArg_ParseTuple(args, "O!O!",
                         &PySoy_bodies_Body_Type, &bodyOne,
                         &PySoy_bodies_Body_Type, &bodyTwo))
        scene = bodyTwo->g->scene;
    else {
        PyErr_Clear();
        if (PyArg_ParseTuple(args, "O!O!",
                             &PySoy_bodies_Body_Type, &bodyOne,
                             &PySoy_scenes_Scene_Type, &pyscene))
            scene = pyscene->g;
        else
            return NULL;
    }

    // Ensure bodies are in the same scene
    if (bodyOne->g->scene != scene) {
        PyErr_SetString(PyExc_ValueError, "Bodies must be in the same scene");
        return NULL;
    }

    self = (SELF) PyType_GenericNew(type, args, NULL);

    if(!self)
        return NULL;

    if(!bodyTwo)
        self->g = soy_joints_joint_new(scene, bodyOne->g, NULL, NULL, NULL, NULL, NULL);
    else
        self->g = soy_joints_joint_new(scene, bodyOne->g, bodyTwo->g, NULL, NULL, NULL, NULL);


    return (PyObject*) self;
}