ovs.stream: Drop Stream.get_name() since clients can use 'name' directly.

[openvswitch] / python / ovs / db / data.py

diff --git a/python/ovs/db/data.py b/python/ovs/db/data.py
index 2d019327834eb52b9aadd1bef333cb0adecea28f..9530fb9cdfc5b873d00a2de0ed9e0caa636ab216 100644 (file)
--- a/python/ovs/db/data.py
+++ b/python/ovs/db/data.py
@@ -64,12 +64,12 @@ def returnUnchanged(x):
     return x
 
 class Atom(object):
-    def __init__(self, type, value=None):
-        self.type = type
+    def __init__(self, type_, value=None):
+        self.type = type_
         if value is not None:
             self.value = value
         else:
-            self.value = type.default_atom()
+            self.value = type_.default_atom()
 
     def __cmp__(self, other):
         if not isinstance(other, Atom) or self.type != other.type:
@@ -85,8 +85,8 @@ class Atom(object):
         return hash(self.value)
 
     @staticmethod
-    def default(type):
-        return Atom(type)
+    def default(type_):
+        return Atom(type_)
 
     def is_default(self):
         return self == self.default(self.type)
@@ -143,12 +143,12 @@ class Atom(object):
             length = len(s)
             if length < base.min_length:
                 raise ConstraintViolation(
-                    "\"%s\" length %d is less than minimum allowed length %d"
+                    '"%s" length %d is less than minimum allowed length %d'
                     % (s, length, base.min_length))
             elif length > base.max_length:
                 raise ConstraintViolation(
-                    "\"%s\" length %d is greater than maximum allowed "
-                    "length %d" % (s, length, base.max_length))
+                    '"%s" length %d is greater than maximum allowed '
+                    'length %d' % (s, length, base.max_length))
     
     def to_json(self):
         if self.type == ovs.db.types.UuidType:
@@ -227,8 +227,8 @@ class Atom(object):
         return Atom(t, x)
 
 class Datum(object):
-    def __init__(self, type, values={}):
-        self.type = type
+    def __init__(self, type_, values={}):
+        self.type = type_
         self.values = values
 
     def __cmp__(self, other):
@@ -250,14 +250,14 @@ class Datum(object):
         return Datum(self.type, dict(self.values))
 
     @staticmethod
-    def default(type):
-        if type.n_min == 0:
+    def default(type_):
+        if type_.n_min == 0:
             values = {}
-        elif type.is_map():
-            values = {type.key.default(): type.value.default()}
+        elif type_.is_map():
+            values = {type_.key.default(): type_.value.default()}
         else:
-            values = {type.key.default(): None}
-        return Datum(type, values)
+            values = {type_.key.default(): None}
+        return Datum(type_, values)
 
     def is_default(self):
         return self == Datum.default(self.type)
@@ -325,14 +325,14 @@ class Datum(object):
             return Datum(type_, {keyAtom: None})
 
     def to_json(self):
-        if len(self.values) == 1 and not self.type.is_map():
+        if self.type.is_map():
+            return ["map", [[k.to_json(), v.to_json()]
+                            for k, v in sorted(self.values.items())]]
+        elif len(self.values) == 1:
             key = self.values.keys()[0]
             return key.to_json()
-        elif not self.type.is_map():
-            return ["set", [k.to_json() for k in sorted(self.values.keys())]]
         else:
-            return ["map", [[k.to_json(), v.to_json()]
-                            for k, v in sorted(self.values.items())]]
+            return ["set", [k.to_json() for k in sorted(self.values.keys())]]
 
     def to_string(self):
         head = tail = None
@@ -402,7 +402,7 @@ class Datum(object):
 
     def conforms_to_type(self):
         n = len(self.values)
-        return n >= self.type.n_min and n <= self.type.n_max
+        return self.type.n_min <= n <= self.type.n_max
 
     def cInitDatum(self, var):
         if len(self.values) == 0: