refactored OpenType() into a mutable object

2 files changed, 30 insertions, 13 deletions

diff --git a/pyasn1/type/namedtype.py b/pyasn1/type/namedtype.py
index cba9524..edcf3ce 100644
--- a/pyasn1/type/namedtype.py
+++ b/pyasn1/type/namedtype.py
@@ -10,6 +10,12 @@ from pyasn1 import error
 
 __all__ = ['NamedType', 'OptionalNamedType', 'DefaultedNamedType', 'NamedTypes']
 
+try:
+    any
+
+except AttributeError:
+    any = lambda x: bool(filter(bool, x))
+
 
 class NamedType(object):
     """Create named field object for a constructed ASN.1 type.
@@ -120,8 +126,11 @@ class NamedTypes(object):
         self.__ambiguousTypes = 'terminal' not in kwargs and self.__computeAmbiguousTypes() or {}
         self.__uniqueTagMap = self.__computeTagMaps(unique=True)
         self.__nonUniqueTagMap = self.__computeTagMaps(unique=False)
-        self.__hasOptionalOrDefault = bool([True for namedType in self.__namedTypes
-                                            if namedType.isDefaulted or namedType.isOptional])
+        self.__hasOptionalOrDefault = any([True for namedType in self.__namedTypes
+                                           if namedType.isDefaulted or namedType.isOptional])
+        self.__hasOpenTypes = any([True for namedType in self.__namedTypes
+                                   if namedType.openType])
+
         self.__requiredComponents = frozenset(
                 [idx for idx, nt in enumerate(self.__namedTypes) if not nt.isOptional and not nt.isDefaulted]
             )
@@ -508,8 +517,12 @@ class NamedTypes(object):
         return self.__hasOptionalOrDefault
 
     @property
+    def hasOpenTypes(self):
+        return self.__hasOpenTypes
+
+    @property
     def namedTypes(self):
-        return iter(self.__namedTypes)
+        return tuple(self.__namedTypes)
 
     @property
     def requiredComponents(self):
diff --git a/pyasn1/type/opentype.py b/pyasn1/type/opentype.py
index 9788a56..c8f0e64 100644
--- a/pyasn1/type/opentype.py
+++ b/pyasn1/type/opentype.py
@@ -21,13 +21,17 @@ class OpenType(object):
     name: :py:class:`str`
         Field name
 
-    *choices:
-        Sequence of (*value*, *type*) tuples representing the mapping 
+    typeMap: :py:class:`dict`:
+        A map of value->ASN.1 type. It's stored by reference and can be
+        mutated later to register new mappings.
     """
 
-    def __init__(self, name, args, **kwargs):
+    def __init__(self, name, typeMap=None):
         self.__name = name
-        self.__choices = dict(args, **kwargs)
+        if typeMap is None:
+            self.__typeMap = {}
+        else:
+            self.__typeMap = typeMap
 
     @property
     def name(self):
@@ -36,19 +40,19 @@ class OpenType(object):
     # Python dict protocol
 
     def values(self):
-        return self.__choices.values()
+        return self.__typeMap.values()
 
     def keys(self):
-        return self.__choices
+        return self.__typeMap.keys()
 
     def items(self):
-        return self.__choices.items()
+        return self.__typeMap.items()
 
     def __contains__(self, key):
-        return key in self.__choices
+        return key in self.__typeMap
 
     def __getitem__(self, key):
-        return self.__choices[key]
+        return self.__typeMap[key]
 
     def __iter__(self):
-        return iter(self.__choices)
+        return iter(self.__typeMap)