Commit 175a4c43 authored by David Gobbi's avatar David Gobbi
Browse files

Make vtkVariantStrictWeakOrder(a,b) work with Py3k.

For Python 2, this method operated like the cmp(a,b) method.  In
Python 3, there is no cmp(a,b) method, so instead this method now
returns (a < b) like the original C++ method.
parent a7996f41
......@@ -18,7 +18,7 @@ import sys
import vtk
from vtk.test import Testing
if sys.hexversion > 0x03000000:
if sys.hexversion >= 0x03000000:
cedilla = 'Fran\xe7ois'
else:
cedilla = unicode('Fran\xe7ois', 'latin1')
......@@ -126,16 +126,27 @@ class TestVariant(Testing.vtkTest):
l.sort()
self.assertEqual(l, s)
def testComparisonMethods(self):
v1 = vtk.vtkVariant(10)
v2 = vtk.vtkVariant("10")
# compare without regards to type
self.assertEqual(vtk.vtkVariantEqual(v1, v2), True)
self.assertEqual(vtk.vtkVariantLessThan(v1, v2), False)
# compare with different types being non-equivalent
self.assertEqual(vtk.vtkVariantStrictEquality(v1, v2), False)
if sys.hexversion >= 0x03000000:
self.assertEqual(vtk.vtkVariantStrictWeakOrder(v1, v2), True)
else:
# for Python 2, it worked like the cmp() function
self.assertEqual(vtk.vtkVariantStrictWeakOrder(v1, v2), -1)
def testStrictWeakOrder(self):
"""Use vtkVariantStrictWeakOrder to sort a list of vtkVariants"""
if sys.hexversion > 0x03000000:
"""sort() doesn't take comparator in py3k"""
return
original = [1, 2.5, vtk.vtkVariant(), "0", cedilla]
ordered = [vtk.vtkVariant(), 1, 2.5, "0", cedilla]
l = [vtk.vtkVariant(x) for x in original]
s = [vtk.vtkVariant(x) for x in ordered]
l.sort(vtk.vtkVariantStrictWeakOrder)
l.sort(key=vtk.vtkVariantStrictWeakOrderKey)
self.assertEqual(l, s)
def testVariantExtract(self):
......
......@@ -3,6 +3,7 @@ Utility functions to mimic the template support functions for vtkVariant
"""
import vtk
import sys
_variant_type_map = {
'void' : vtk.VTK_VOID,
......@@ -126,10 +127,11 @@ def vtkVariantCast(v, t):
def vtkVariantStrictWeakOrder(s1, s2):
"""
Compare variants by type first, and then by value. The return values
are -1, 0, 1 like the python cmp() method, for compatibility with the
python list sort() method. This is in contrast with the C++ version,
which returns true or false.
Compare variants by type first, and then by value. When called from
within a Python 2 interpreter, the return values are -1, 0, 1 like the
cmp() method, for compatibility with the Python 2 list sort() method.
This is in contrast with the Python 3 version of this method (and the
VTK C++ version), which return true or false.
"""
s1 = vtk.vtkVariant(s1)
s2 = vtk.vtkVariant(s2)
......@@ -137,28 +139,64 @@ def vtkVariantStrictWeakOrder(s1, s2):
t1 = s1.GetType()
t2 = s2.GetType()
# define a cmp(x, y) for Python 3 that returns (x < y)
def vcmp(x, y):
if sys.hexversion >= 0x03000000:
return (x < y)
else:
return cmp(x,y)
# check based on type
if t1 != t2:
return cmp(t1,t2)
return vcmp(t1,t2)
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) and (not v2):
return 0
elif v1 != v2:
return cmp(v1,v2)
if (not v1) or (not v2):
return vcmp(v1,v2)
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
# compare vtk objects by classname
# compare vtk objects by classname, then address
if t1 == vtk.VTK_OBJECT:
return cmp(r1.GetClassName(), r2.GetClassName())
return cmp(r1, r2)
c1 = r1.GetClassName()
c2 = r2.GetClassName()
if c1 != c2:
return vcmp(c1,c2)
else:
return vcmp(r1.__this__,r2.__this__)
return vcmp(r1, r2)
if sys.hexversion >= 0x03000000:
class vtkVariantStrictWeakOrderKey:
"""A key method (class, actually) for use with sort()"""
def __init__(self, obj, *args):
self.obj = obj
def __lt__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other)
else:
class vtkVariantStrictWeakOrderKey:
"""A key method (class, actually) for use with sort()"""
def __init__(self, obj, *args):
self.obj = obj
def __lt__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other) < 0
def __gt__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other) > 0
def __eq__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other) == 0
def __le__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other) <= 0
def __ge__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other) >= 0
def __ne__(self, other):
return vtkVariantStrictWeakOrder(self.obj, other) != 0
def vtkVariantStrictEquality(s1, s2):
......@@ -193,14 +231,14 @@ def vtkVariantStrictEquality(s1, s2):
def vtkVariantLessThan(s1, s2):
"""
Return true if s1 < s2. This isn't very useful in Python.
Return true if s1 < s2.
"""
return (vtk.vtkVariant(s1) < vtk.vtkVariant(s2))
def vtkVariantEqual(s1, s2):
"""
Return true if s1 == s2. This isn't very useful in Python.
Return true if s1 == s2.
"""
return (vtk.vtkVariant(s1) == vtk.vtkVariant(s2))
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment