Ignore:
Timestamp:
01/04/10 16:38:01 (10 years ago)
Author:
pjkersha
Message:

Added AttributeValueFactory? to generate <type>AttributeValue? classes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attributevalue.py

    r6792 r6797  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12from datetime import datetime, timedelta 
     13 
     14from ndg.xacml.utils import VettedDict 
    1215from ndg.xacml.core.expression import Expression 
    1316     
     
    1619    """XACML Attribute Value type""" 
    1720    ELEMENT_LOCAL_NAME = 'AttributeValue' 
     21    CLASS_NAME_SUFFIX = 'AttributeValue' 
     22    IDENTIFIER_PREFIX = 'http://www.w3.org/2001/XMLSchema#' 
     23    IDENTIFIER = None 
     24    TYPE_MAP = { 
     25        'String': basestring, 
     26        'AnyURI': basestring, 
     27        'Integer': int, 
     28        'Boolean': bool, 
     29        'Double': float, 
     30        'Date': datetime, 
     31        'DateTime': datetime, 
     32        'Time': datetime, 
     33        'DayTimeDuration': timedelta, 
     34        'YearMonthDuration': timedelta, 
     35        'X500Name': basestring, 
     36        'Rfc822Name': basestring, 
     37        'HexBinary': int, 
     38        'Base64Binary': NotImplemented 
     39    } 
     40    TYPE = None 
     41     
    1842    __slots__ = ('__value',)  
    1943     
     
    2650 
    2751    def _set_value(self, value): 
    28         if not isinstance(value, basestring): 
     52        if not isinstance(value, self.__class__.TYPE): 
    2953            raise TypeError('Expecting %r type for "value" ' 
    30                             'attribute; got %r' % (basestring, type(value))) 
     54                            'attribute; got %r' % (self.__class__.TYPE,  
     55                                                   type(value))) 
    3156             
    3257        self.__value = value   
     
    4368        """  
    4469        return self.__value 
     70 
     71 
     72class AttributeValueClassMap(VettedDict): 
     73    """Specialised dictionary to hold mappings of XML attribute type URIs to  
     74    their equivalent classes 
     75    """ 
     76     
     77    def __init__(self): 
     78        """Force entries to derive from AttributeValue and IDs to 
     79        be string type 
     80        """         
     81        # Filters are defined as staticmethods but reference via self here to  
     82        # enable derived class to override them as standard methods without 
     83        # needing to redefine this __init__ method             
     84        super(AttributeValueClassMap, self).__init__(self.keyFilter,  
     85                                                     self.valueFilter) 
     86         
     87    @staticmethod 
     88    def keyFilter(key): 
     89        """Enforce string type keys""" 
     90        if not isinstance(key, basestring): 
     91            raise TypeError('Expecting %r type for key; got %r' %  
     92                            (basestring, type(key)))  
     93        return True  
     94     
     95    @staticmethod 
     96    def valueFilter(value): 
     97        """Enforce AttributeValue derived types for values""" 
     98 
     99        if not issubclass(value, AttributeValue): 
     100            raise TypeError('Expecting %r derived type for value; got %r' %  
     101                            (AttributeValue, type(value)))  
     102        return True  
     103 
     104 
     105# Dynamically Create classes based on AttributeValue for all the XACML primitive 
     106# types 
     107_IDENTIFIER2CLASS_MAP = AttributeValueClassMap() 
     108 
     109for typeName, _type in AttributeValue.TYPE_MAP.items(): 
     110    identifier = AttributeValue.IDENTIFIER_PREFIX + typeName[0 
     111                                                        ].lower() + typeName[1:] 
     112 
     113    className = typeName + AttributeValue.CLASS_NAME_SUFFIX                
     114    classVars = {'TYPE': _type, 'IDENTIFIER_NS': identifier} 
     115     
     116    attributeValueClass = type(className, (AttributeValue, ), classVars) 
     117    AttributeValue.register(attributeValueClass) 
     118    _IDENTIFIER2CLASS_MAP[identifier] = attributeValueClass 
     119     
     120     
     121class AttributeValueFactory(object): 
     122    """Create AttributeValue types based on the XML namespace identifier 
     123     
     124    Convenience wrapper for _IDENTIFIER2CLASS_MAP instance of  
     125    AttributeValueClassMap 
     126    """ 
     127    def __init__(self, classMap=None): 
     128        if classMap is None: 
     129            self.__classMap = _IDENTIFIER2CLASS_MAP 
     130        elif isinstance(classMap, AttributeValueClassMap): 
     131            self.__classMap = classMap 
     132        else: 
     133            raise TypeError('Expecting %r derived type for "map" input; got %r' 
     134                            % (AttributeValueClassMap, type(map))) 
     135             
     136    def __call__(self, identifier): 
     137        """Return <type>AttributeValue class for given identifier URI or None 
     138        if no match is found 
     139        """ 
     140        return self.__classMap.get(identifier) 
     141         
Note: See TracChangeset for help on using the changeset viewer.