PyObject *py_ped_geometry_test_equal(PyObject *s, PyObject *args) {
int ret = -1;
PyObject *in_b = NULL;
PedGeometry *out_a = NULL, *out_b = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_b)) {
return NULL;
}
out_a = _ped_Geometry2PedGeometry(s);
if (out_a == NULL) {
return NULL;
}
out_b = _ped_Geometry2PedGeometry(in_b);
if (out_b == NULL) {
return NULL;
}
ret = ped_geometry_test_equal(out_a, out_b);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_geometry_map(PyObject *s, PyObject *args) {
int ret = -1;
PyObject *in_dst = NULL;
PedGeometry *out_dst = NULL, *src = NULL;
PedSector sector;
if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_dst,
§or)) {
return NULL;
}
src = _ped_Geometry2PedGeometry(s);
if (src == NULL) {
return NULL;
}
out_dst = _ped_Geometry2PedGeometry(in_dst);
if (out_dst == NULL) {
return NULL;
}
ret = ped_geometry_map(out_dst, src, sector);
if (ret == -1) {
PyErr_SetString(PyExc_ArithmeticError, "Sector must exist within region given by geometry");
return NULL;
}
return Py_BuildValue("i", ret);
}
/* _ped_Constraint -> PedConstraint functions */
PedConstraint *_ped_Constraint2PedConstraint(PyObject *s) {
PedConstraint *ret = NULL;
PedAlignment *start_align = NULL, *end_align = NULL;
PedGeometry *start_range = NULL, *end_range = NULL;
_ped_Constraint *constraint = (_ped_Constraint *) s;
if (constraint == NULL) {
PyErr_SetString(PyExc_TypeError, "Empty _ped.Constraint()");
return NULL;
}
start_align = _ped_Alignment2PedAlignment(constraint->start_align);
if (start_align == NULL) {
return NULL;
}
end_align = _ped_Alignment2PedAlignment(constraint->end_align);
if (end_align == NULL) {
ped_alignment_destroy(start_align);
return NULL;
}
start_range = _ped_Geometry2PedGeometry(constraint->start_range);
if (start_range == NULL) {
ped_alignment_destroy(start_align);
ped_alignment_destroy(end_align);
return NULL;
}
end_range = _ped_Geometry2PedGeometry(constraint->end_range);
if (end_range == NULL) {
ped_alignment_destroy(start_align);
ped_alignment_destroy(end_align);
return NULL;
}
ret = ped_constraint_new(start_align, end_align, start_range, end_range,
constraint->min_size, constraint->max_size);
if (ret == NULL) {
/* Fall through to clean up memory, but set the error condition now. */
PyErr_NoMemory();
}
ped_alignment_destroy(start_align);
ped_alignment_destroy(end_align);
return ret;
}
PyObject *py_ped_constraint_is_solution(PyObject *s, PyObject *args) {
PyObject *in_geometry = NULL;
PedConstraint *constraint = NULL;
PedGeometry *out_geometry = NULL;
int ret = 0;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj,
&in_geometry)) {
return NULL;
}
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
out_geometry = _ped_Geometry2PedGeometry(in_geometry);
if (out_geometry == NULL) {
ped_constraint_destroy(constraint);
return NULL;
}
ret = ped_constraint_is_solution(constraint, out_geometry);
ped_constraint_destroy(constraint);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_constraint_new_from_max(PyObject *s, PyObject *args) {
PyObject *in_max = NULL;
PedGeometry *out_max = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_max)) {
return NULL;
}
out_max = _ped_Geometry2PedGeometry(in_max);
if (out_max == NULL) {
return NULL;
}
constraint = ped_constraint_new_from_max(out_max);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create new constraint from max");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
PyObject *py_ped_constraint_exact(PyObject *s, PyObject *args) {
PyObject *in_geometry = NULL;
PedGeometry *out_geometry = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_geometry)) {
return NULL;
}
out_geometry = _ped_Geometry2PedGeometry(in_geometry);
if (out_geometry == NULL) {
return NULL;
}
constraint = ped_constraint_exact(out_geometry);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create exact constraint");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
/* 1:1 function mappings for geom.h in libparted */
PyObject *py_ped_geometry_duplicate(PyObject *s, PyObject *args) {
PedGeometry *geometry = NULL, *geom = NULL;
_ped_Geometry *ret = NULL;
geometry = _ped_Geometry2PedGeometry(s);
if (geometry == NULL) {
return NULL;
}
geom = ped_geometry_duplicate(geometry);
if (geom) {
ret = PedGeometry2_ped_Geometry(geom);
}
else {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(CreateException, partedExnMessage);
}
else
PyErr_SetString(CreateException, "Could not duplicate geometry");
return NULL;
}
return (PyObject *) ret;
}
PyObject *py_ped_file_system_probe(PyObject *s, PyObject *args) {
PyObject *in_geom = NULL;
PedGeometry *out_geom = NULL;
PedFileSystemType *fstype = NULL;
_ped_FileSystemType *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_geom)) {
return NULL;
}
out_geom = _ped_Geometry2PedGeometry(in_geom);
if (!out_geom) {
return NULL;
}
fstype = ped_file_system_probe(out_geom);
if (fstype) {
ret = PedFileSystemType2_ped_FileSystemType(fstype);
}
else {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(IOException, partedExnMessage);
}
else
PyErr_SetString(FileSystemException, "Failed to find any filesystem in given geometry");
return NULL;
}
return (PyObject *) ret;
}
PyObject *py_ped_geometry_set_end(PyObject *s, PyObject *args) {
int ret = -1;
PedGeometry *geom = NULL;
PedSector end;
if (!PyArg_ParseTuple(args, "L", &end)) {
return NULL;
}
geom = _ped_Geometry2PedGeometry(s);
if (geom == NULL) {
return NULL;
}
ret = ped_geometry_set_end(geom, end);
if (ret == 0) {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(CreateException, partedExnMessage);
}
else
PyErr_SetString(CreateException, "Could not create new geometry");
return NULL;
}
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_unit_parse(PyObject *s, PyObject *args) {
int ret;
char *str = NULL;
PedDevice *out_dev = NULL;
PedSector sector;
PyObject *in_geom = NULL;
PedGeometry *out_geom = NULL;
if (!PyArg_ParseTuple(args, "zLO!", &str, §or,
&_ped_Geometry_Type_obj, &in_geom)) {
return NULL;
}
out_dev = _ped_Device2PedDevice(s);
if (out_dev == NULL) {
return NULL;
}
out_geom = _ped_Geometry2PedGeometry(in_geom);
if (out_geom == NULL) {
return NULL;
}
ret = ped_unit_parse(str, out_dev, §or, &out_geom);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_alignment_is_aligned(PyObject *s, PyObject *args) {
int ret = -1;
PyObject *in_geom = NULL;
PedAlignment *align = NULL;
PedGeometry *out_geom = NULL;
PedSector sector;
if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_geom, §or)) {
return NULL;
}
align = _ped_Alignment2PedAlignment(s);
if (align == NULL) {
return NULL;
}
out_geom = _ped_Geometry2PedGeometry(in_geom);
if (out_geom == NULL) {
return NULL;
}
ret = ped_alignment_is_aligned(align, out_geom, sector);
ped_alignment_destroy(align);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_alignment_align_nearest(PyObject *s, PyObject *args) {
PyObject *in_geom = NULL;
PedAlignment *align = NULL;
PedGeometry *out_geom = NULL;
PedSector sector, ret;
if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_geom, §or)) {
return NULL;
}
align = _ped_Alignment2PedAlignment(s);
if (align == NULL) {
return NULL;
}
out_geom = _ped_Geometry2PedGeometry(in_geom);
if (out_geom == NULL) {
return NULL;
}
ret = ped_alignment_align_nearest(align, out_geom, sector);
ped_alignment_destroy(align);
if (ret == -1) {
PyErr_SetString(PyExc_ArithmeticError, "Could not align to closest sector");
return NULL;
}
return PyLong_FromLong(ret);
}
/* 1:1 function mappings for constraint.h in libparted */
PyObject *py_ped_constraint_new_from_min_max(PyObject *s, PyObject *args) {
PyObject *in_min = NULL, *in_max = NULL;
PedGeometry *out_min = NULL, *out_max = NULL;
PedConstraint *constraint = NULL;
_ped_Constraint *ret = NULL;
if (!PyArg_ParseTuple(args, "O!O!", &_ped_Geometry_Type_obj, &in_min,
&_ped_Geometry_Type_obj, &in_max)) {
return NULL;
}
out_min = _ped_Geometry2PedGeometry(in_min);
if (out_min == NULL) {
return NULL;
}
out_max = _ped_Geometry2PedGeometry(in_max);
if (out_max == NULL) {
return NULL;
}
/* ped_constraint_new_from_min_max will ASSERT if this isn't enforced. */
if (!ped_geometry_test_inside(out_max, out_min)) {
PyErr_SetString(CreateException, "min geometry must be contained within max geometry");
return NULL;
}
constraint = ped_constraint_new_from_min_max(out_min, out_max);
if (constraint) {
ret = PedConstraint2_ped_Constraint(constraint);
}
else {
PyErr_SetString(CreateException, "Could not create new constraint from min/max");
return NULL;
}
ped_constraint_destroy(constraint);
return (PyObject *) ret;
}
PyObject *py_ped_geometry_intersect(PyObject *s, PyObject *args) {
PyObject *in_b = NULL;
PedGeometry *out_a = NULL, *out_b = NULL, *geom = NULL;
_ped_Geometry *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_b)) {
return NULL;
}
out_a = _ped_Geometry2PedGeometry(s);
if (out_a == NULL) {
return NULL;
}
out_b = _ped_Geometry2PedGeometry(in_b);
if (out_b == NULL) {
return NULL;
}
geom = ped_geometry_intersect (out_a, out_b);
if (geom) {
ret = PedGeometry2_ped_Geometry(geom);
}
else {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(CreateException, partedExnMessage);
}
else
PyErr_SetString(PyExc_ArithmeticError, "Could not find geometry intersection");
return NULL;
}
return (PyObject *) ret;
}
PyObject *py_ped_geometry_read(PyObject *s, PyObject *args) {
PyObject *ret = NULL;
PedGeometry *geom = NULL;
char *out_buf = NULL;
PedSector offset, count;
if (!PyArg_ParseTuple(args, "LL", &offset, &count)) {
return NULL;
}
geom = _ped_Geometry2PedGeometry(s);
if (geom == NULL) {
return NULL;
}
/* py_device_read will ASSERT if the device isn't open yet. */
if (geom->dev->open_count <= 0) {
PyErr_SetString(IOException, "Attempting to read from a unopened device");
return NULL;
}
/* And then py_geometry_read will ASSERT on these things too. */
if (offset < 0 || count < 0) {
PyErr_SetString(IOException, "offset and count cannot be negative.");
return NULL;
}
if ((out_buf = malloc(geom->dev->sector_size * count)) == NULL) {
return PyErr_NoMemory();
}
if (ped_geometry_read(geom, out_buf, offset, count) == 0) {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(IOException, partedExnMessage);
}
else
PyErr_SetString(IOException, "Could not read from given region");
free(out_buf);
return NULL;
}
ret = PyString_FromString(out_buf);
free(out_buf);
return ret;
}
PyObject *py_ped_geometry_write(PyObject *s, PyObject *args) {
int ret = -1;
char *in_buf = NULL;
PedGeometry *geom = NULL;
PedSector offset, count;
if (!PyArg_ParseTuple(args, "sLL", &in_buf, &offset, &count)) {
return NULL;
}
geom = _ped_Geometry2PedGeometry(s);
if (geom == NULL) {
return NULL;
}
/* py_device_write will ASSERT if the device isn't open yet. */
if (geom->dev->open_count <= 0) {
PyErr_SetString(IOException, "Attempting to write to a unopened device");
return NULL;
}
/* And then py_geometry_wriet will ASSERT on these things too. */
if (offset < 0 || count < 0) {
PyErr_SetString(IOException, "offset and count cannot be negative.");
return NULL;
}
ret = ped_geometry_write(geom, in_buf, offset, count);
if (ret == 0) {
if (partedExnRaised) {
partedExnRaised = 0;
if (!PyErr_ExceptionMatches(PartedException) &&
!PyErr_ExceptionMatches(PyExc_NotImplementedError))
PyErr_SetString(IOException, partedExnMessage);
}
else
PyErr_SetString(IOException, "Could not write to given region");
return NULL;
}
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_geometry_check(PyObject *s, PyObject *args) {
PyObject *in_timer = NULL;
PedGeometry *geom = NULL;
PedSector offset, granularity, count, ret;
PedTimer *out_timer = NULL;
char *out_buf = NULL;
if (!PyArg_ParseTuple(args, "LLL|O!", &offset, &granularity, &count,
&_ped_Timer_Type_obj, &in_timer)) {
return NULL;
}
geom = _ped_Geometry2PedGeometry(s);
if (geom == NULL) {
return NULL;
}
if (!geom->dev->open_count) {
PyErr_Format(IOException, "Device %s is not open.", geom->dev->path);
return NULL;
}
if (geom->dev->external_mode) {
PyErr_Format(IOException, "Device %s is already open for external access.", geom->dev->path);
return NULL;
}
if (in_timer)
out_timer = _ped_Timer2PedTimer(in_timer);
else
out_timer = NULL;
if ((out_buf = malloc(geom->dev->sector_size * 32)) == NULL) {
ped_timer_destroy(out_timer);
return PyErr_NoMemory();
}
ret = ped_geometry_check(geom, out_buf, 32, offset,
granularity, count, out_timer);
ped_timer_destroy(out_timer);
free(out_buf);
return PyLong_FromLongLong(ret);
}
PyObject *py_ped_geometry_sync_fast(PyObject *s, PyObject *args) {
int ret = -1;
PedGeometry *geom = NULL;
geom = _ped_Geometry2PedGeometry(s);
if (geom == NULL) {
return NULL;
}
ret = ped_geometry_sync_fast(geom);
if (ret == 0) {
PyErr_SetString(IOException, "Could not sync");
return NULL;
}
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_file_system_probe_specific(PyObject *s, PyObject *args) {
PyObject *in_geom = NULL, *in_fstype = NULL;
PedFileSystemType *fstype = NULL;
PedGeometry *out_geom = NULL, *geom = NULL;
_ped_Geometry *ret = NULL;
if (!PyArg_ParseTuple(args, "O!O!", &_ped_FileSystemType_Type_obj,
&in_fstype, &_ped_Geometry_Type_obj, &in_geom)) {
return NULL;
}
fstype = _ped_FileSystemType2PedFileSystemType(in_fstype);
if (!fstype) {
return NULL;
}
out_geom = _ped_Geometry2PedGeometry(in_geom);
if (!out_geom) {
return NULL;
}
geom = ped_file_system_probe_specific(fstype, out_geom);
if (geom) {
ret = PedGeometry2_ped_Geometry(geom);
} else {
/* libparted swallows exceptions here (I think) and just returns
* NULL if the match is not made. Reset exception flag and return
* None.
*/
if (partedExnRaised) {
partedExnRaised = 0;
}
Py_INCREF(Py_None);
return Py_None;
}
return (PyObject *) ret;
}
PyObject *py_ped_geometry_test_sector_inside(PyObject *s, PyObject *args) {
int ret = -1;
PedGeometry *geom = NULL;
PedSector sector;
if (!PyArg_ParseTuple(args, "L", §or)) {
return NULL;
}
geom = _ped_Geometry2PedGeometry(s);
if (geom == NULL) {
return NULL;
}
ret = ped_geometry_test_sector_inside(geom, sector);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_unit_parse_custom(PyObject *s, PyObject *args) {
int ret;
char *str = NULL;
PedDevice *out_dev = NULL;
int unit;
PedSector sector;
PyObject *in_geom = NULL;
PedGeometry *out_geom = NULL;
if (!PyArg_ParseTuple(args, "ziLO!", &str, &unit, §or,
&_ped_Geometry_Type_obj, &in_geom)) {
return NULL;
}
if (unit < PED_UNIT_FIRST || unit > PED_UNIT_LAST) {
PyErr_SetString(PyExc_ValueError, "Invalid unit provided.");
return NULL;
}
out_dev = _ped_Device2PedDevice(s);
if (out_dev == NULL) {
return NULL;
}
out_geom = _ped_Geometry2PedGeometry(in_geom);
if (out_geom == NULL) {
return NULL;
}
ret = ped_unit_parse_custom(str, out_dev, unit, §or, &out_geom);
if (ret) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
PyObject *py_ped_constraint_solve_nearest(PyObject *s, PyObject *args) {
PyObject *in_geometry = NULL;
PedConstraint *constraint = NULL;
PedGeometry *out_geometry = NULL;
PedGeometry *geometry = NULL;
_ped_Geometry *ret = NULL;
if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj,
&in_geometry)) {
return NULL;
}
constraint = _ped_Constraint2PedConstraint(s);
if (constraint == NULL) {
return NULL;
}
out_geometry = _ped_Geometry2PedGeometry(in_geometry);
if (out_geometry == NULL) {
ped_constraint_destroy(constraint);
return NULL;
}
geometry = ped_constraint_solve_nearest(constraint, out_geometry);
ped_constraint_destroy(constraint);
if (geometry) {
ret = PedGeometry2_ped_Geometry(geometry);
}
else {
PyErr_SetString(PyExc_ArithmeticError, "Could not find region nearest to constraint for given geometry");
return NULL;
}
return (PyObject *) ret;
}
int _ped_Constraint_init(_ped_Constraint *self, PyObject *args,
PyObject *kwds) {
static char *kwlist[] = {"start_align", "end_align", "start_range",
"end_range", "min_size", "max_size", NULL};
PedConstraint *constraint = NULL;
PedAlignment *start_align = NULL, *end_align = NULL;
PedGeometry *start_range = NULL, *end_range = NULL;
if (kwds == NULL) {
if (!PyArg_ParseTuple(args, "O!O!O!O!LL",
&_ped_Alignment_Type_obj, &self->start_align,
&_ped_Alignment_Type_obj, &self->end_align,
&_ped_Geometry_Type_obj, &self->start_range,
&_ped_Geometry_Type_obj, &self->end_range,
&self->min_size, &self->max_size)) {
self->start_align = self->end_align = NULL;
self->start_range = self->end_range = NULL;
return -1;
}
} else {
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!O!LL", kwlist,
&_ped_Alignment_Type_obj,
&self->start_align,
&_ped_Alignment_Type_obj,
&self->end_align,
&_ped_Geometry_Type_obj,
&self->start_range,
&_ped_Geometry_Type_obj,
&self->end_range,
&self->min_size,
&self->max_size)) {
self->start_align = self->end_align = NULL;
self->start_range = self->end_range = NULL;
return -2;
}
}
/*
* try to call libparted with provided information,
* on failure, raise an exception
*/
start_align = _ped_Alignment2PedAlignment(self->start_align);
end_align = _ped_Alignment2PedAlignment(self->end_align);
start_range = _ped_Geometry2PedGeometry(self->start_range);
end_range = _ped_Geometry2PedGeometry(self->end_range);
constraint = ped_constraint_new(start_align, end_align,
start_range, end_range,
self->min_size, self->max_size);
if (constraint == NULL) {
PyErr_SetString(CreateException, "Could not create new constraint");
ped_alignment_destroy(start_align);
ped_alignment_destroy(end_align);
self->start_align = NULL;
self->end_align = NULL;
self->start_range = NULL;
self->end_range = NULL;
return -3;
}
/* increment reference count for PyObjects read by PyArg_ParseTuple */
Py_INCREF(self->start_align);
Py_INCREF(self->end_align);
Py_INCREF(self->start_range);
Py_INCREF(self->end_range);
/* clean up libparted objects we created */
ped_alignment_destroy(start_align);
ped_alignment_destroy(end_align);
ped_constraint_destroy(constraint);
return 0;
}